//           principal.C
//  Ter janeiro 04 15:43:37 2011
//  Copyright  2011  Alcione Ferreira
//  <user@host>

#include <principal.h>

using namespace std;
using namespace Gtk::Menu_Helpers;

/**
 *
 */
COLUNAS::COLUNAS()
	{
	this->n_campos = 7;
	add(this->descricao);
	add(this->cod_func);
	add(this->cod_acesso);
	add(this->cod_cli);
	add(codigo);
	add(this->tipo_jur);
	add(this->cod_serv);
	add(this->tipo_serv);
	add(this->sel_recibo);
	add(this->imposto);
	add(this->credito);
	add(this->sub_issqn);
	add(tipo);
	add(data);
	add(recibo);
	add(valor);
	for(int i=0; i< this->n_campos; i++)
		{
		add(this->campo[i]);
		}
	add(this->campo_n);
	}

/**
 *
 */
COLUNAS::~COLUNAS()
	{
			
	}

/**
 * Construtor da Classe PRINCIPAL
 */
PRINCIPAL::PRINCIPAL()
  	{
	int i, arq_size;
	string about_text, aux;
	char *buf_aux;
	ifstream copying;
	//this->importa = passagem;
	this->data_hoje = new char[15];
	this->data_hoje = hoje();
	this->logado = 0;
	//Criação de Janelas
	this->p_status = this->c_status = this->cs_status = this->c_clistatus = this->c_servstatus = this->baixabstatus = this->saldos_status = 0;
	aux.clear();
	aux.append(IMG_PATH);
	aux+="caixa.ico";
	this->ponteiro_icon=Gdk::Pixbuf::create_from_file (aux);
	this->Login.set_title(Glib::ustring("CAIXA: Login de Acesso"));
	this->Login.set_size_request(280,150);
	this->Login.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	this->Login.set_position(Gtk::WIN_POS_CENTER);
	this->Login.set_icon(this->ponteiro_icon);
	this->Login.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),2));
	this->LoginB.set_homogeneous(false);
	this->LoginB.set_spacing(false);
	this->LoginUL.set_label("Login:");
	this->LoginUE.signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),2));
	this->LoginUE.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),2));
	this->LoginSL.set_label("Senha:");
	this->LoginSE.set_visibility(false);
	this->LoginSE.set_invisible_char('*');
	this->LoginSE.signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),3));
	this->LoginOK = new Gtk::Button(Gtk::Stock::OK);
	this->LoginOK->set_size_request(90,28);
	this->LoginOK->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::checar_login));
	this->LoginCancel= new Gtk::Button(Gtk::Stock::CANCEL);
	this->LoginCancel->set_size_request(90,28);
	this->LoginCancel->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),2));
	this->LoginT.put(this->LoginUL,10,20);
	this->LoginT.put(this->LoginUE,70,15);
	this->LoginT.put(this->LoginSL,10,60);
	this->LoginT.put(this->LoginSE,70,55);
	this->LoginT.put(*this->LoginOK,10,100);
	this->LoginT.put(*this->LoginCancel,150,100);
	this->LoginB.pack_start(this->LoginT);
	this->Login.add(this->LoginB);
	this->Login.set_focus(this->LoginUE);

  	this->Login.show_all();	
 	}

/**
 * Destrutor da Classe PRINCIPAL
 */
PRINCIPAL::~PRINCIPAL()
  	{
	if (this->p_status == 1)
		{
		delete this->conexao;
		}
  	}

/**
 * Checa junto ao banco de dados o acesso do usuários, pegando as informações
 * digitadas na tela de PRINCIPAL::Login.
 */
void PRINCIPAL::checar_login()
	{
	string usuario, senha;
	char *sql;
	int resposta;
	BANCOPG *teste;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	teste = new BANCOPG(CONF_FILE);
	//cout << teste->mensagem << endl;
	resposta = 0;
	usuario.clear();
	senha.clear();
	sql = new char[150];
	usuario = this->LoginUE.get_text();
	senha = this->LoginSE.get_text();

	sprintf(sql,"select nome, acesso, cod_fun from cadastro.funcionario where u_login='%s' and senha=md5('%s')",usuario.c_str(),senha.c_str());
	teste->executar(sql);
	resposta = teste->registros;
	if (resposta == 1)
		{
		teste->resultado();
		ir = teste->resultados.begin();
		linha = *ir;
		this->logado = 1;
		this->cod_func = linha.at(2);
		this->login = usuario;
		this->senha = senha;
		this->nome = linha.at(0);
		this->n_acesso = atoi(linha.at(1).c_str());
		this->sair(2);
		this->janelas = 1;
		this->carregar_janela();
		}
	else
		{
		Gtk::MessageDialog dialog(this->Login, Glib::ustring("Falha na autenticação"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring("Verifique seu Login/Senha e tente novamente!"));
		dialog.run();
		this->LoginUE.set_text("");
		this->LoginSE.set_text("");
		this->Login.set_focus(this->LoginUE);
		}

	delete sql, teste;
	}

/**
 * Fecha as janelas do sistema.
 * \param fechar indica qual janela deve ser fechada.
 */
void PRINCIPAL::sair(int fechar)
	{
	switch(fechar)
		{
		case 1:
			{
			/*if (this->c_status == 1)
				{
				this->Conta.hide();
				}
			if (this->cs_status == 1)
				{
				this->Contas.hide();
				}
			if (this->c_clistatus == 1)
				{
				this->Cliente.hide();
				}
			if (this->c_servstatus ==1)
				{
				this->Servico.hide();
				}
			if (this->baixabstatus == 1)
				{
				this->BaixaB.hide();
				}
			if (this->saldos_status == 1)
				{
				this->Saldos.hide();
				}*/
			this->Principal.hide(); //FECHA O PROGRAMA
			break;
			}
		case 2:
			{
			this->Login.hide();
			break;
			}
		case 3:
			{
			this->About.hide();
			break;
			}
		case 4:
			{
			this->Cliente.hide();
			break;
			}
		case 5:
			{
			this->Servico.hide();
			break;
			}
		case 6:
			{
			this->Novo->hide();
			this->carregar_dados();
			break;
			}
		case 7:
			{
			this->Editar->hide();
			this->carregar_dados();
			break;
			}
		case 8:
			{
			this->BaixaB.hide();
			break;
			}
		case 9:
			{
			this->Saldos.hide();
			break;
			}
		case 10:
			{
			Editar->hide();
			break;
			}
		}
	}

/**
 * Este método é controlado por PRINCIPAL::janelas que indica qual janela do 
 * sistema será carregada.
 * 1 - PRINCIPAL::Principal\n
 * 4 - PRINCIPAL::Conta\n
 * 5 - PRINCIPAL::Contas\n
 * 6 - PRINCIPAL::Cliente\n
 * 7 - PRINCIPAL::Servico\n
 * 8 - PRINCIPAL::BaixaB\n
 * 9 - PRINCIPAL::Saldos\n
 */
void PRINCIPAL::carregar_janela()
	{
	int i, arq_size;
	string about_text, aux;
	char *buf_aux;
	ifstream copying;
	switch(this->janelas)
		{
		case 1:
			{
			if (this->p_status == 0)
				{
				this->conexao = new BANCOPG(CONF_FILE);
				this->p_status = 1;
				this->Principal.set_title("Caixa");
  				this->Principal.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Principal.set_position(Gtk::WIN_POS_CENTER);
				this->Principal.set_icon(this->ponteiro_icon);
				this->Principal.maximize();
				this->Principal.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),1));
				//this->Principal.signal_show().connect(sigc::mem_fun(*this,&PRINCIPAL::run));
				this->BufferCR = TCreditos.get_buffer();
			  	this->BufferCR->set_text("");
				this->tag = this->BufferCR->create_tag("quebra");
				this->tag->property_wrap_mode () = Gtk::WRAP_WORD;
				this->BufferLIC = TLicenca.get_buffer();
			  	this->BufferLIC->set_text("");
				this->tag = this->BufferLIC->create_tag("quebra");
				this->tag->property_wrap_mode () = Gtk::WRAP_WORD;

				//Membros Janela ABOUTMSG
				this->About.set_size_request(500,300);
				this->About.set_title("About::CAIXA");
				this->About.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->About.set_position(Gtk::WIN_POS_CENTER);
				this->About.set_icon(this->ponteiro_icon);
				this->AboutBOX.set_homogeneous(false);
				this->AboutBOX.set_spacing(0);
				this->About1.set_homogeneous(true);
				this->About1.set_spacing(0);
				aux.clear();
				aux.append(IMG_PATH);
				aux+="logo.xpm";
				this->LogoAbout.set(aux);
				this->About1.pack_start(this->LogoAbout,true,true,0);
				this->LinkAbout.set_label(Glib::ustring("Sombra® Designer Visual"));
				this->LinkAbout.set_uri("http://www.alcionesytes.net/");
				this->About1.pack_start(this->LinkAbout,true,true,0);
				this->AboutBOX.pack_start(this->About1,false,false,0);
				this->About2.set_homogeneous(true);
				this->About2.set_spacing(0);
				this->GuiasAbout.set_border_width(10);
				this->BarraT1.add(this->TCreditos);
				this->BarraT1.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->TCreditos.set_editable(false);
				this->TCreditos.set_justification(Gtk::JUSTIFY_FILL);
				copying.open("CREDITS");
				if (copying.is_open())
					{
					//cout << "Aberto" << endl;
					copying.seekg (0, ios::end);
				  	arq_size = copying.tellg();
				  	copying.seekg (0, ios::beg);
				  	buf_aux = new char [arq_size];
				  	copying.read (buf_aux,arq_size);
					}
				else
					{
					cout << "Erro" << endl;
					}
				copying.close();
				about_text.clear();
				about_text.append(buf_aux);
				delete buf_aux;
				this->BufferCR->set_text("");
				this->iter = this->BufferCR->get_iter_at_offset(0);
				this->BufferCR->insert(this->iter,Glib::ustring(about_text));
				this->TCreditos.set_buffer(this->BufferCR);
				this->BufferCR->get_bounds(this->inicio, this->final);
				this->BufferCR->apply_tag_by_name("quebra", this->inicio, this->final);
				this->BarraT2.add(this->TLicenca);
				this->BarraT2.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->TLicenca.set_editable(false);
				this->TLicenca.set_justification(Gtk::JUSTIFY_FILL);
				copying.open("README");
				if (copying.is_open())
					{
					//cout << "Aberto" << endl;
					copying.seekg (0, ios::end);
				  	arq_size = copying.tellg();
				  	copying.seekg (0, ios::beg);
				  	buf_aux = new char [arq_size];
				  	copying.read (buf_aux,arq_size);
					}
				else
					{
					cout << "Erro" << endl;
					}
				copying.close();
				about_text.clear();
				about_text.append(buf_aux);
				delete buf_aux;
				this->BufferLIC->set_text("");
				this->iter = this->BufferLIC->get_iter_at_offset(0);
				this->BufferLIC->insert(this->iter,Glib::ustring(about_text));
				this->TLicenca.set_buffer(this->BufferLIC);
				this->BufferLIC->get_bounds(this->inicio, this->final);
				this->BufferLIC->apply_tag_by_name("quebra", this->inicio, this->final);
				this->GuiasAbout.append_page(this->BarraT1,Glib::ustring("Créditos"));
				this->GuiasAbout.append_page(this->BarraT2,Glib::ustring("Licença"));
				this->About2.pack_start(this->GuiasAbout,true,true,0);
				this->AboutBOX.pack_start(this->About2,true,true,0);
				this->About3.set_homogeneous(false);
				this->About3.set_spacing(0);
				this->AboutOK.set_label("Fechar");
				this->AboutOK.set_size_request(80,25);
				this->AboutOK.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),3));
				this->About3.pack_end(this->AboutOK,false,false,0);
				this->AboutBOX.pack_start(this->About3,false,false,0);
				this->About.add(this->AboutBOX);
				//Membros Janela ABOUTMSG END
				this->Box_Principal.set_homogeneous(false);		//DEFINE SE TODOS OS FILHOS TERÃO O MESMO TAMANHO DO BOX DO PAI 
				this->Box_Principal.set_spacing(0);				//ESPAÇAMENTO ENTRE BOX FILHOS
	
	  			//BOX ONDE COLOCAREMOS OS ITENS DO MENU	
				this->Box_Menu.set_homogeneous(true);
				this->Box_Menu.set_spacing(0);
				//Barra de Menus
				this->menu_barra = Gtk::manage(new Gtk::MenuBar());

				//Menu: Ferramentas	
					{
					Gtk::Menu::MenuList& menulist = this->MenuFerr.items();
					menulist.push_back( MenuElem(Glib::ustring("_Minha Conta"),Gtk::AccelKey("<control>M"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::m_conta),4)));
				  	if (this->n_acesso == 0)
						{
						menulist.push_back( MenuElem(Glib::ustring("_Usuários"),Gtk::AccelKey("<control>L"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::m_conta),5)));
						}
					if ((this->importa == 1)&&(this->n_acesso == 0))
						{
						menulist.push_back( MenuElem(Glib::ustring("_Importação"),MenuFerrImp));
						}				
					menulist.push_back(SeparatorElem());
			    	menulist.push_back( MenuElem(Glib::ustring("_Configurações"), MenuFerrConf) );
					menulist.push_back(SeparatorElem());
			    	menulist.push_back(MenuElem("_Sair",Gtk::AccelKey("<alt>F4"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::sair),1)));
					}
				//SubMenu: Importação
					{
					Gtk::Menu::MenuList& menulist = this->MenuFerrImp.items();
					menulist.push_back(MenuElem(Glib::ustring("F_uncionários"),Gtk::AccelKey("<control>U"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),1)));
					menulist.push_back(MenuElem(Glib::ustring("Serviços _Entrada"),Gtk::AccelKey("<control>E"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),2)));	
					menulist.push_back(MenuElem(Glib::ustring("Serviços _Saída"),Gtk::AccelKey("<control>S"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),3)));
					menulist.push_back(MenuElem(Glib::ustring("_Clientes"),Gtk::AccelKey("<control>C"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),4)));
					menulist.push_back(MenuElem(Glib::ustring("Lançamen_tos"),MenuFerrImpLanc));
					}
				//SubMenu: Importação->Lançamentos
					{
					Gtk::Menu::MenuList& menulist = this->MenuFerrImpLanc.items();
					menulist.push_back(MenuElem(Glib::ustring("_Geral"),Gtk::AccelKey("<control>X"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),5)));
					menulist.push_back(MenuElem(Glib::ustring("_Detalhamento"),Gtk::AccelKey("<control>Z"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),6)));
					menulist.push_back(MenuElem(Glib::ustring("_Saídas"),Gtk::AccelKey("<control>K"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),7)));
					menulist.push_back(MenuElem(Glib::ustring("Sal_dos"),Gtk::AccelKey("<control>P"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::importar),8)));
					}
				this->editar_conexao(true);	//INCIALIZA JANELA ANTES
				//SubMenu: Configurações
					{
			    	Gtk::Menu::MenuList& menulist = this->MenuFerrConf.items();
					if (this->n_acesso == 0)
						{
						menulist.push_back(MenuElem("Checagem _Imposto", Gtk::AccelKey("<control>I"),sigc::mem_fun(*this, &PRINCIPAL::checagem_impostoT)));
			    		menulist.push_back(MenuElem("_Editar arquivo", Gtk::AccelKey("<control>E"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::editar_conexao),false)));
						}
			  		menulist.push_back(MenuElem(Glib::ustring("_Teste de Conexão"),Gtk::AccelKey("<control>T"),sigc::mem_fun(*this, &PRINCIPAL::testar_conexao)));
					//menulist.push_back(MenuElem(Glib::ustring("Relógio"),Gtk::AccelKey("<control>U"),sigc::mem_fun(*this, &PRINCIPAL::run)));
					}
				/*SubMenu: Configurações->Imposto
				    {
					Gtk::Menu::MenuList& menulist = this->MenuImposto.items();
					menulist.push_back(MenuElem(Glib::ustring("_Funjecc 10%"),Gtk::AccelKey("<control>F"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::checagem_imposto),1)));
					menulist.push_back(MenuElem(Glib::ustring("_ISSQN 5%"),Gtk::AccelKey("<control>Q"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::checagem_imposto),1)));
					}*/
				//Menu Cadastro
					{
					Gtk::Menu::MenuList& menulist = this->MenuCadastro.items();
					menulist.push_back(MenuElem(Glib::ustring("Cl_ientes"),Gtk::AccelKey("<control>I"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::m_cadastro),6)));
				  	menulist.push_back(MenuElem(Glib::ustring("S_erviços"),Gtk::AccelKey("<control>E"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::m_cadastro),7)));
					}
				 //Menu Controle Financeiro
                    {
					Gtk::Menu::MenuList& menulist = this->MenuFinanceiro.items();
					if ((this->n_acesso == 0)||(this->caixa))
						{
						menulist.push_back(MenuElem(Glib::ustring("_Baixar Débitos"),Gtk::AccelKey("<control>B"),sigc::mem_fun(*this, &PRINCIPAL::baixar_debitos)));
						menulist.push_back(MenuElem(Glib::ustring("Saldos do _Sistema"),Gtk::AccelKey("<control>S"),sigc::mem_fun(*this, &PRINCIPAL::saldos_sistema)));
						menulist.push_back(MenuElem(Glib::ustring("Re-_Impressão"),Gtk::AccelKey("<control>I"),sigc::mem_fun(*this, &PRINCIPAL::imprimir_credLote)));
						menulist.push_back(MenuElem(Glib::ustring("Livro Diário Auxiliar"),Gtk::AccelKey("<control>L"),sigc::mem_fun(*this, &PRINCIPAL::livro_caixa)));
						if ((n_acesso == 0)|| adm )
							{
							menulist.push_back(MenuElem(Glib::ustring("Contas Corrente"),MenuFinConta));
							}
						}
					if ((this->n_acesso == 0)||(this->escritura))
						{
						menulist.push_back(MenuElem(Glib::ustring("Escrituras"),Gtk::AccelKey("<control>E"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),13)));
						}
					menulist.push_back (MenuElem(Glib::ustring("_Ajuste Recibo"),Gtk::AccelKey("<control>A"),sigc::mem_fun(*this, &PRINCIPAL::ajustar_centavos)));
					}
				 //Sub-Menu Controle Financeiro->Contas Corrent
					{
					Gtk::Menu::MenuList& menulist = MenuFinConta.items();
					menulist.push_back(MenuElem(Glib::ustring("_Cadastros"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::cconta),1)));	
					}
				 //Menu Relatório
                  	{
					Gtk::Menu::MenuList& menulist = this->MenuRelatorio.items();
					menulist.push_back(MenuElem(Glib::ustring("_Serviços"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),1)));
					if (this->n_acesso <= 5)
						{
						menulist.push_back(MenuElem(Glib::ustring("Serviços/_Funcionário"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),2)));
						}
					menulist.push_back(MenuElem(Glib::ustring("Ser_viços/Selos"),this->MenuRelSerSel));
					if (this->n_acesso <= 5)
						{
						menulist.push_back(MenuElem(Glib::ustring("_Créditos"),MenuRelCred));
						menulist.push_back(MenuElem(Glib::ustring("_Recibos por Funcionário"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),5)));
						menulist.push_back(MenuElem(Glib::ustring("_Resumos"),MenuRelRes));
						}
					menulist.push_back(MenuElem(Glib::ustring("Consulta R_ecibos"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),8)));
					if ((this->n_acesso == 0)||(this->caixa))
						{
						menulist.push_back(MenuElem(Glib::ustring("Consultar Rec _D/C"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),9)));
						}
				  	}
				//Sub-Menu Relatório->Créditos
                    {
					Gtk::Menu::MenuList& menulist = this->MenuRelCred.items();
					menulist.push_back(MenuElem(Glib::ustring("Por _Período"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),3)));
					menulist.push_back(MenuElem(Glib::ustring("Por _Cliente"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),4)));
					}
				//Sub-Menu Relatórios->Resumos
                    {
					Gtk::Menu::MenuList& menulist = this->MenuRelRes.items();
					menulist.push_back(MenuElem(Glib::ustring("_Entradas"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),6)));
					if ((this->n_acesso == 0)||(this->caixa))
						{
						menulist.push_back(MenuElem(Glib::ustring("_Saídas"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),7)));
						menulist.push_back(MenuElem(Glib::ustring("_SubISSQN"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),14)));
						}
					}
				//Sub-Menu Relatórios->Serviços/Selos
                    {
					Gtk::Menu::MenuList& menulist = this->MenuRelSerSel.items();
					menulist.push_back(MenuElem(Glib::ustring("_Individual"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),10)));
					menulist.push_back(MenuElem(Glib::ustring("_Geral"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),11)));
					if (this->n_acesso == 0)
						{
						menulist.push_back(MenuElem(Glib::ustring("_Conferência"),sigc::bind(sigc::mem_fun(*this, &PRINCIPAL::relatorio),12)));
						}
					}
				//Organizando menu
				this->menu_barra->items().push_back(MenuElem(Glib::ustring("_Ferramentas"),Gtk::AccelKey("<alt>F"),this->MenuFerr));
				this->menu_barra->items().push_back(MenuElem(Glib::ustring("_Cadastro"),Gtk::AccelKey("<alt>C"),this->MenuCadastro));
				this->menu_barra->items().push_back(MenuElem(Glib::ustring("_Recibo"),Gtk::AccelKey("<control>R"),sigc::mem_fun(*this, &PRINCIPAL::recibo)));
				if ((this->n_acesso == 0)||(this->caixa)||(this->escritura))
		            {
					this->menu_barra->items().push_back(MenuElem(Glib::ustring("_Controle Financeiro"),Gtk::AccelKey("<alt>C"),this->MenuFinanceiro));
					}
				this->menu_barra->items().push_back(MenuElem(Glib::ustring("R_elatório"),Gtk::AccelKey("<alt>E"),this->MenuRelatorio));                
				this->menu_barra->items().push_back(MenuElem(Glib::ustring("_Sobre"),Gtk::AccelKey("<alt>S"),sigc::mem_fun(*this, &PRINCIPAL::info)));
			  	this->Box_Conteudo.set_homogeneous(false);
			  	this->Box_Conteudo.set_spacing(0);
				string status;
				status.clear();
				status = "Sombra® Designer Visual - ";
				status.append(data_formatada(this->data_hoje,2));
				status += " - ";
				status.append(agora());
				status += " - Usuário: "+this->nome;
				this->statusbar1 = this->BarraStatus1.push(Glib::ustring(status));
				this->Box_Conteudo.pack_end(this->BarraStatus1,false,true,0);
				//ORGANIZANDO A BOX PRINCIPAL:
			  	this->Box_Menu.pack_start(*this->menu_barra,true,true,0);
			  	this->Box_Principal.pack_start(this->Box_Menu,false,false,0);
			  	this->Box_Principal.pack_start(this->Box_Conteudo,true,true,0);
			  	this->Principal.add(this->Box_Principal);
				Glib::signal_timeout().connect(sigc::mem_fun(*this,&PRINCIPAL::run), 1000);
				this->Principal.show_all();
				Gtk::Main::run(this->Principal);
				}
			else
				{
				this->Principal.show_all();
				Gtk::Main::run(this->Principal);
				}
			break;
			}
		case 4:
			{
			if (this->c_status == 0)
				{
				this->c_status = 1;
				this->Conta.set_title(Glib::ustring("Minha Conta"));
				this->Conta.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Conta.set_position(Gtk::WIN_POS_CENTER);
				this->Conta.set_icon(this->ponteiro_icon);
				this->Conta.set_size_request(330,150);
				this->CL_Nome.set_label("Nome: ");
				this->CE_Nome.set_size_request(260,28);
				this->CE_Nome.set_sensitive(false);
				this->CF_Tela.put(this->CL_Nome,10,10);
				this->CF_Tela.put(this->CE_Nome,60,5);
				this->CL_Login.set_label("Login: ");
				this->CE_Login.set_size_request(260,28);
				this->CE_Login.set_sensitive(false);
				this->CE_Login.signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),4));
				this->CF_Tela.put(this->CL_Login,10,40);
				this->CF_Tela.put(this->CE_Login,60,35);
				this->CL_Senha.set_label("Senha: ");
				this->CE_Senha.set_size_request(120,28);
				this->CE_Senha.set_sensitive(false);
				this->CE_Senha.set_visibility(false);
				this->CE_Senha.set_invisible_char('$');
				this->CC_Senha.set_label("Mostrar Senha");
				this->CC_Senha.signal_toggled().connect(sigc::mem_fun(*this,&PRINCIPAL::mostrar_senha));
				this->CF_Tela.put(this->CL_Senha,10,70);
				this->CF_Tela.put(this->CE_Senha,60,65);
				this->CF_Tela.put(this->CC_Senha,190,70);
				this->CB_Alt = new Gtk::Button(Gtk::Stock::EDIT);
				this->CB_Alt->set_size_request(100,30);
				this->CB_Alt->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::editar_dados));
				this->CB_AltS = new Gtk::Button(Gtk::Stock::DIALOG_AUTHENTICATION);
				this->CB_AltS->set_label("_Senha");
				this->CB_AltS->set_size_request(100,30);
				this->CB_AltS->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::mudar_senha));
				this->CB_Salvar = new Gtk::Button(Gtk::Stock::APPLY);
				this->CB_Salvar->set_size_request(100,30);
				this->CB_Salvar->set_sensitive(false);
				this->CB_Salvar->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_alterado));
				this->CF_Tela.put(*this->CB_Alt,15,110);
				this->CF_Tela.put(*this->CB_AltS,120,110);
				this->CF_Tela.put(*this->CB_Salvar,225,110);
				
				this->Conta.add(CF_Tela);
				this->carregar_dados();
				this->Conta.show_all();
				Gtk::Main::run(this->Conta);
				}
			else
				{
				this->carregar_dados();
				this->Conta.show_all();
				Gtk::Main::run(this->Conta);
				}
			break;
			}
		case 5:
			{
			//cout << this->Contas.get_modal() << endl;
			if (this->cs_status == 0)
				{
				this->cs_status = 1;
				this->Contas.set_title(Glib::ustring("Gerenciamento de Usuários"));
				this->Contas.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Contas.set_position(Gtk::WIN_POS_CENTER);
				this->Contas.set_icon(this->ponteiro_icon);
				this->Contas.set_size_request(400,200);
				//this->Contas.signal_show().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::teste),1));
				this->VB_Contas.set_homogeneous(false);
				this->VB_Contas.set_spacing(0);
				this->HB_MContas.set_homogeneous(false);
				this->HB_MContas.set_spacing(0);
				this->LC_Contas.set_label("Nome: ");
				this->EC_Contas.set_size_request(100,28);
				this->EC_Contas.signal_changed().connect(sigc::mem_fun(*this,&PRINCIPAL::carregar_dados));
				this->HB_MContas.pack_start(this->LC_Contas,false,false,0);
				this->HB_MContas.pack_start(this->EC_Contas,false,false,0);
				this->TBN_Contas.set_stock_id(Gtk::Stock::NEW);
				this->TBN_Contas.set_tooltip_text(Glib::ustring("Novo Funcionário"));
				this->TBN_Contas.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::novo));
				this->TBE_Contas.set_stock_id(Gtk::Stock::EDIT);
				this->TBE_Contas.set_tooltip_text(Glib::ustring("Editar Funcionário Selecionado"));
				this->TBE_Contas.set_sensitive(false);
				this->TBE_Contas.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::editar_dados));
				this->TBD_Contas.set_stock_id(Gtk::Stock::CANCEL);
				this->TBD_Contas.set_tooltip_text(Glib::ustring("Deletar Funcionário Selecionado"));
				this->TBD_Contas.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::deletar));
				this->TBD_Contas.set_sensitive(false);
				this->TB_Contas.append(this->STB_Contas);
				this->TB_Contas.append(this->TBN_Contas);
				this->TB_Contas.append(this->TBE_Contas);
				this->TB_Contas.append(this->TBD_Contas);
				this->HB_MContas.pack_start(this->TB_Contas,true,true,0);
				this->HB_CContas.set_homogeneous(false);
				this->HB_CContas.set_spacing(0);
				this->CSContas.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->CSContas.add(this->CTContas);
				this->CTContas.signal_row_activated().connect(sigc::mem_fun(*this,&PRINCIPAL::selecionado));
				this->HB_CContas.pack_start(this->CSContas);
				this->VB_Contas.pack_start(this->HB_MContas,false,false,0);
				this->VB_Contas.pack_start(this->HB_CContas,true,true,0);
				this->Contas.add(VB_Contas);
				this->carregar_dados();
				this->Contas.show_all();
				Gtk::Main::run(this->Contas);
				}
			else
				{
				this->TBE_Contas.set_sensitive(false);
				this->TBD_Contas.set_sensitive(false);
				this->carregar_dados();
				this->Contas.show_all();
				Gtk::Main::run(this->Contas);
				}
			break;
			}
		case 6:
			{
			if (this->c_clistatus == 0)
				{
				this->c_clistatus = 1;
				this->Cliente.set_title(Glib::ustring("Cadastro de Clientes"));
				this->Cliente.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Cliente.set_position(Gtk::WIN_POS_CENTER);
				this->Cliente.set_icon(this->ponteiro_icon);
				this->Cliente.set_size_request(600,400);
				this->Cliente.signal_show().connect(sigc::mem_fun(*this,&PRINCIPAL::carregar_dados));
				this->Cliente.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),4));
				this->VB_Cliente.set_homogeneous(false);
				this->VB_Cliente.set_spacing(0);
				this->HB_MCliente.set_homogeneous(false);
				this->HB_MCliente.set_spacing(0);
				this->LC_Cliente.set_label("Nome: ");
				this->EC_Cliente.set_size_request(200,28);
				this->EC_Cliente.signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),6));
				this->TI_Cliente[0].add(this->LC_Cliente);
				this->TI_Cliente[1].add(this->EC_Cliente);
				this->TBN_Cliente.set_stock_id(Gtk::Stock::NEW);
				this->TBN_Cliente.set_tooltip_text(Glib::ustring("Novo Cliente"));
				this->TBN_Cliente.set_sensitive (false);
				this->TBN_Cliente.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::novo));
				this->TBE_Cliente.set_stock_id(Gtk::Stock::EDIT);
				this->TBE_Cliente.set_tooltip_text(Glib::ustring("Editar Cliente Selecionado"));
				this->TBE_Cliente.set_sensitive(false);
				this->TBE_Cliente.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::editar_dados));
				this->TBD_Cliente.set_stock_id(Gtk::Stock::CANCEL);
				this->TBD_Cliente.set_tooltip_text(Glib::ustring("Deletar Cliente Selecionado"));
				this->TBD_Cliente.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::deletar));
				this->TBD_Cliente.set_sensitive(false);
				this->TB_Cliente.append(this->TI_Cliente[0]);
				this->TB_Cliente.append(this->TI_Cliente[1]);					
				this->TB_Cliente.append(this->STB_Cliente);
				this->TB_Cliente.append(this->TBN_Cliente);
				this->TB_Cliente.append(this->TBE_Cliente);
				this->TB_Cliente.append(this->TBD_Cliente);
				this->HB_MCliente.pack_start(this->TB_Cliente,true,true,0);
				this->HB_CCliente.set_homogeneous(false);
				this->HB_CCliente.set_spacing(0);
				this->CS_Cliente.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->CS_Cliente.add(this->CT_Cliente);
				this->HB_CCliente.pack_start(this->CS_Cliente);
				this->VB_Cliente.pack_start(this->HB_MCliente,false,false,0);
				this->VB_Cliente.pack_start(this->HB_CCliente,true,true,0);
				this->Cliente.add(this->VB_Cliente);
				if ((this->n_acesso == 0)||(this->caixa))
					{
					this->TBN_Cliente.set_sensitive (true);
					this->CT_Cliente.signal_row_activated().connect(sigc::mem_fun(*this,&PRINCIPAL::selecionado));
					}
				this->Cliente.show_all();
				Gtk::Main::run(this->Cliente);
				}
			else
				{
				this->Cliente.show_all();
				Gtk::Main::run(this->Cliente);
				}
			break;
			}
		case 7:
			{
			if (this->c_servstatus == 0)
				{
				this->c_servstatus = 1;
				this->Servico.set_title(Glib::ustring("Cadastro de Serviços"));
				this->Servico.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Servico.set_position(Gtk::WIN_POS_CENTER);
				this->Servico.set_icon(this->ponteiro_icon);
				this->Servico.set_size_request(420,400);
				this->Servico.signal_show().connect(sigc::mem_fun(*this,&PRINCIPAL::carregar_dados));
				this->Servico.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),5));
				this->VB_Servico.set_homogeneous(false);
				this->VB_Servico.set_spacing(0);
				this->HB_MServico.set_homogeneous(false);
				this->HB_MServico.set_spacing(0);
				this->LC_Servico.set_label("Descrição: ");
				this->EC_Servico.set_size_request(100,28);
				this->EC_Servico.signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),7));
				this->TI_Servico[0].add(this->LC_Servico);
				this->TI_Servico[1].add (this->EC_Servico);
				this->TBN_Servico.set_stock_id(Gtk::Stock::NEW);
				this->TBN_Servico.set_tooltip_text(Glib::ustring("Novo Serviço"));
				this->TBN_Servico.set_sensitive (false);
				this->TBN_Servico.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::novo));
				this->TBE_Servico.set_stock_id(Gtk::Stock::EDIT);
				this->TBE_Servico.set_tooltip_text(Glib::ustring("Editar Serviço Selecionado"));
				this->TBE_Servico.set_sensitive(false);
				this->TBE_Servico.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::editar_dados));
				this->TBD_Servico.set_stock_id(Gtk::Stock::CANCEL);
				this->TBD_Servico.set_tooltip_text(Glib::ustring("Deletar Serviço Selecionado"));
				this->TBD_Servico.signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::deletar));
				this->TBD_Servico.set_sensitive(false);
				this->TB_Servico.append(this->TI_Servico[0]);
				this->TB_Servico.append(this->TI_Servico[1]);
				this->TB_Servico.append(this->STB_Servico);
				this->TB_Servico.append(this->TBN_Servico);
				this->TB_Servico.append(this->TBE_Servico);
				this->TB_Servico.append(this->TBD_Servico);
				this->HB_MServico.pack_start(this->TB_Servico,true,true,0);
				this->HB_CServico.set_homogeneous(false);
				this->HB_CServico.set_spacing(0);
				this->CS_Servico.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->CS_Servico.add(this->CT_Servico);
				this->HB_CServico.pack_start(this->CS_Servico);
				this->VB_Servico.pack_start(this->HB_MServico,false,false,0);
				this->VB_Servico.pack_start(this->HB_CServico,true,true,0);
				this->Servico.add(this->VB_Servico);
				if ((this->n_acesso == 0)||(this->caixa))
					{
					this->TBN_Servico.set_sensitive (true);
					this->CT_Servico.signal_row_activated().connect(sigc::mem_fun(*this,&PRINCIPAL::selecionado));
					}
				this->Servico.show_all();
				Gtk::Main::run(this->Servico);
				}
			else
				{
				this->TBE_Servico.set_sensitive(false);
				this->TBD_Servico.set_sensitive(false);
				this->Servico.show_all();
				Gtk::Main::run(this->Servico);
				}
			break;
			}
		case 8:
			{
			if (this->baixabstatus == 0)
				{
				this->baixabstatus = 1;
				this->BaixaB.set_title(Glib::ustring("Baixa de Débitos"));
				this->BaixaB.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->BaixaB.set_position(Gtk::WIN_POS_CENTER);
				this->BaixaB.set_icon(this->ponteiro_icon);
				this->BaixaB.set_size_request(520,280);
				//this->Servico.signal_show().connect(sigc::mem_fun(*this,&PRINCIPAL::carregar_dados));
				this->BaixaB.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),8));
				this->BaixaB_Principal.set_homogeneous (false);
				this->BaixaB_Principal.set_spacing (0);
				this->BaixaB_FConsulta.set_label(Glib::ustring("Pesquisar Cliente"));
				this->BaixaB_Consulta.set_homogeneous (false);
				this->BaixaB_Consulta.set_spacing (0);
				this->BaixaB_Consultas[0].set_homogeneous (false);
				this->BaixaB_Consultas[0].set_spacing (0);
				this->BaixaB_L[3].set_label (Glib::ustring ("Período de: "));
				this->BaixaB_Consultas[0].pack_start(this->BaixaB_L[3],false,false,0);
				this->BaixaB_DataI.set_size_request (100,-1);
				this->BaixaB_DataI.set_max_length (10);
				this->BaixaB_DataI.set_text(data_formatada(hoje(),2));
				this->BaixaB_DataI.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checagem),3));
				this->BaixaB_DataI.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular2),&this->BaixaB,&this->BaixaB_DataF));
				this->BaixaB_Consultas[0].pack_start(this->BaixaB_DataI,false,false,0);
				this->BaixaB_L[4].set_label (Glib::ustring (" á "));
				this->BaixaB_Consultas[0].pack_start(this->BaixaB_L[4],false,false,0);
				this->BaixaB_DataF.set_size_request (100,-1);
				this->BaixaB_DataF.set_max_length (10);
				this->BaixaB_DataF.set_text(data_formatada(hoje(),2));
				this->BaixaB_DataF.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular2),&this->BaixaB,&this->BaixaB_Codigo));
				this->BaixaB_DataF.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checagem),4));
				this->BaixaB_Consultas[0].pack_start(this->BaixaB_DataF,false,false,0);
				this->BaixaB_Consultas[1].set_homogeneous (false);
				this->BaixaB_Consultas[1].set_spacing (0);
				this->BaixaB_L[0].set_label (Glib::ustring ("Código: "));
				this->BaixaB_Consultas[1].pack_start(this->BaixaB_L[0],false,false,0);
				this->BaixaB_Codigo.set_size_request (70,-1);
				this->BaixaB_Codigo.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),&this->BaixaB_Codigo,2));
				this->BaixaB_Codigo.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_debito),&this->BaixaB_Codigo,1));
				this->BaixaB_Consultas[1].pack_start(this->BaixaB_Codigo,false,false,0);
				this->BaixaB_L[1].set_label (Glib::ustring ("Nome: "));
				this->BaixaB_Consultas[1].pack_start(this->BaixaB_L[1],false,false,0);
				this->BaixaB_Nome.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),10));
				this->BaixaB_Nome.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_debito),&this->BaixaB_Nome,2));
				this->BNomes_List = Gtk::EntryCompletion::create();
				this->BaixaB_Nome.set_completion(this->BNomes_List);
				this->baixa_nome = Gtk::ListStore::create(this->arvore_reg);
				this->BNomes_List->set_model(this->baixa_nome);
				this->preparar_dados (1);
				this->BaixaB_Consultas[1].pack_start(this->BaixaB_Nome,true,true,0);
				this->BaixaB_Consultas[2].set_homogeneous (false);
				this->BaixaB_Consultas[2].set_spacing (0);
				this->BaixaB_L[5].set_label (Glib::ustring ("Número: "));
				this->BaixaB_Consultas[2].pack_start(this->BaixaB_L[5],false,false,0);
				this->BaixaB_Numero.signal_changed ().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),&this->BaixaB_Numero,2));
				this->BaixaB_Numero.signal_activate ().connect (sigc::mem_fun (*this,&PRINCIPAL::checar_recibo));
				this->BaixaB_Consultas[2].pack_start(this->BaixaB_Numero,false,false,0);
				this->BaixaB_Consulta.pack_start(this->BaixaB_Consultas[0],false,false,0);
				this->BaixaB_Consulta.pack_start(this->BaixaB_Consultas[1],false,false,0);
				this->BaixaB_Consulta.pack_start(this->BaixaB_Consultas[2],false,false,0);
				this->BaixaB_FConsulta.add(this->BaixaB_Consulta);
				this->BaixaB_Principal.pack_start(this->BaixaB_FConsulta,false,false,0);
				this->S_Debitos.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->S_Debitos.add(this->T_Debitos);
				this->baixa_debitos = Gtk::ListStore::create(this->arvore_reg);
				this->T_Debitos.set_model(this->baixa_debitos);
				this->T_Debitos.remove_all_columns();
				this->T_Debitos.append_column_editable(Glib::ustring("Selecionar"), this->arvore_reg.sel_recibo);
				this->T_Debitos.append_column(Glib::ustring("Data"), this->arvore_reg.campo[0]);
				this->T_Debitos.append_column(Glib::ustring("Recibo"), this->arvore_reg.campo[1]);
				this->T_Debitos.append_column(Glib::ustring("Valor"), this->arvore_reg.campo[2]);
				this->T_Debitos.append_column(Glib::ustring("Funcionário"), this->arvore_reg.campo[3]);
				this->T_Debitos.append_column(Glib::ustring("Cliente"), this->arvore_reg.campo[4]);
				this->BaixaB_Principal.pack_start(this->S_Debitos,true,true,0);
				this->BaixaB_Baixa.set_homogeneous (false);
				this->BaixaB_Baixa.set_spacing (0);
				this->BaixaB_L[2].set_label(Glib::ustring("Data da Baixa: "));
				this->BaixaB_Baixa.pack_start(this->BaixaB_L[2],false,false,0);
				this->BaixaB_DataB.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checagem),1));
				this->BaixaB_DataB.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),5));
				this->BaixaB_DataB.set_max_length (10);
				this->BaixaB_DataB.set_size_request (90,-1);
				this->BaixaB_DataB.set_text(data_formatada(hoje(),2));
				this->BaixaB_Baixa.pack_start(this->BaixaB_DataB,false,false,0);
				this->BaixaB_Baixar =  new Gtk::Button();
				aux.clear();
				aux.append(IMG_PATH);
				aux += "ok.png";
				this->BaixaB_Baixar->add_pixlabel (aux,"Baixar");
				this->BaixaB_Baixar->set_size_request (-1,-1);
				this->BaixaB_Baixar->signal_clicked ().connect (sigc::mem_fun(*this,&PRINCIPAL::baixar_recibos));
				this->BaixaB_Baixa.pack_start(*this->BaixaB_Baixar,false,false,0);
				this->BaixaB_Principal.pack_start(this->BaixaB_Baixa,false,false,0);
				this->BaixaB.add(this->BaixaB_Principal);
				this->BaixaB.set_focus(this->BaixaB_DataI);
				this->BaixaB.show_all();
				Gtk::Main::run(this->BaixaB);
				}
			else
				{
				this->BaixaB.set_focus(this->BaixaB_Codigo);
				this->BaixaB.show_all();
				Gtk::Main::run(this->BaixaB);
				}
			break;
			}
		case 9:
			{
			if (this->saldos_status == 0)
				{
				this->saldos_status = 1;
				this->Saldos.set_title(Glib::ustring("..::Saldos do Sistema::.."));
				this->Saldos.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Saldos.set_position(Gtk::WIN_POS_CENTER);
				this->Saldos.set_icon(this->ponteiro_icon);
				this->Saldos.set_size_request(372,520);
				this->Saldos.signal_show().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::saldos),1));
				this->Saldos.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),9));
				this->Saldos_Principal.set_homogeneous (false);
				this->Saldos_Principal.set_spacing (0);
				this->Saldos_Menu.set_homogeneous (false);
				this->Saldos_Menu.set_spacing (0);
				this->Saldos_ToolButton[0].set_stock_id(Gtk::Stock::NEW);
				this->Saldos_ToolButton[0].set_tooltip_text(Glib::ustring("Cadastrar Saldo"));
				this->Saldos_ToolButton[0].signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::saldos_novo));
				this->Saldos_ToolButton[1].set_stock_id(Gtk::Stock::EDIT);
				this->Saldos_ToolButton[1].set_tooltip_text(Glib::ustring("Alterar Saldo"));
				this->Saldos_ToolButton[1].signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::saldos_alterar));
				this->Saldos_ToolButton[2].set_stock_id(Gtk::Stock::GO_BACK);
				this->Saldos_ToolButton[2].signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::saldos_paginar),1));
				this->Saldos_ToolButton[2].set_tooltip_text(Glib::ustring("Saldo Anterior"));
				this->Saldos_ToolButton[3].set_stock_id(Gtk::Stock::GO_FORWARD);
				this->Saldos_ToolButton[3].signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::saldos_paginar),2));
				this->Saldos_ToolButton[3].set_tooltip_text(Glib::ustring("Próximo Saldo"));
				this->Saldos_ToolButton[4].set_stock_id(Gtk::Stock::CLOSE);
				this->Saldos_ToolButton[4].set_tooltip_text(Glib::ustring("Fechar"));					
				this->Saldos_ToolButton[4].signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::sair),9));
				for (i=0; i < 5; i++)
					{
					this->Saldos_MToolBar.append (this->Saldos_ToolButton[i]);
					}
				this->Saldos_Menu.pack_start(this->Saldos_MToolBar,true,true,0);
				this->Saldos_Principal.pack_start(this->Saldos_Menu,false,false,0);
				this->Saldos_Data.set_homogeneous (false);
				this->Saldos_Data.set_spacing (0);
				this->Saldos_Label[0].set_label(Glib::ustring ("Data: "));
				this->Saldos_Data.pack_start (this->Saldos_Label[0],false,false,0);
				this->Saldos_EData.set_size_request (105,-1);
				this->Saldos_EData.set_max_length (10);
				this->Saldos_EData.signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checagem),2));
				this->Saldos_EData.signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),7));
				this->Saldos_Data.pack_start (this->Saldos_EData,false,false,0);
				this->Saldos_Atualizar.set_label (Glib::ustring ("Atualizar"));
				this->Saldos_Atualizar.signal_clicked ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::saldos_calcular),1));
				this->Saldos_Data.pack_start(this->Saldos_Atualizar,false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Data,false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Linhas[0],Gtk::PACK_SHRINK,5);
				this->Saldos_Saldo[0].set_homogeneous (false);
				this->Saldos_Saldo[0].set_spacing (0);
				this->Saldos_Label[1].set_label(Glib::ustring("Saldo Anterior: \t\t\t"));
				this->Saldos_Saldo[0].pack_start (this->Saldos_Label[1],false,false,0);
				this->Saldos_ESaldo[0].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[0].set_editable (false);
				this->Saldos_Saldo[0].pack_start (this->Saldos_ESaldo[0],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[0],false,false,5);
				this->Saldos_Saldo[1].set_homogeneous (false);
				this->Saldos_Saldo[1].set_spacing (0);
				this->Saldos_Label[2].set_label(Glib::ustring("Entradas do dia: \t\t\t"));
				this->Saldos_Saldo[1].pack_start (this->Saldos_Label[2],false,false,0);
				this->Saldos_ESaldo[1].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[1].set_editable (false);
				this->Saldos_Saldo[1].pack_start (this->Saldos_ESaldo[1],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[1],false,false,5);
				this->Saldos_Saldo[9].set_homogeneous (false);
				this->Saldos_Saldo[9].set_spacing (0);
				this->Saldos_Label[9].set_label(Glib::ustring("Entradas do dia (OnLine): \t"));
				this->Saldos_Saldo[9].pack_start (this->Saldos_Label[9],false,false,0);
				this->Saldos_ESaldo[8].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[8].signal_activate ().connect (sigc::bind(sigc::mem_fun (*this,&PRINCIPAL::saldos_calcular),3));
				this->Saldos_Saldo[9].pack_start (this->Saldos_ESaldo[8],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[9],false,false,5);
				this->Saldos_Saldo[2].set_homogeneous (false);
				this->Saldos_Saldo[2].set_spacing (0);
				this->Saldos_Label[3].set_label(Glib::ustring("Saídas do dia: \t\t\t\t"));
				this->Saldos_Saldo[2].pack_start (this->Saldos_Label[3],false,false,0);
				this->Saldos_ESaldo[2].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[2].set_editable (false);
				this->Saldos_Saldo[2].pack_start (this->Saldos_ESaldo[2],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[2],false,false,5);
				this->Saldos_Saldo[3].set_homogeneous (false);
				this->Saldos_Saldo[3].set_spacing (0);
				this->Saldos_Label[4].set_label(Glib::ustring("Saldo do Sistema: \t\t\t"));
				this->Saldos_Saldo[3].pack_start (this->Saldos_Label[4],false,false,0);
				this->Saldos_ESaldo[3].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[3].set_editable (false);
				this->Saldos_Saldo[3].pack_start (this->Saldos_ESaldo[3],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[3],false,false,5);
				this->Saldos_Principal.pack_start(this->Saldos_Linhas[1],Gtk::PACK_SHRINK,5);
				this->Saldos_Saldo[4].set_homogeneous (false);
				this->Saldos_Saldo[4].set_spacing (0);
				this->Saldos_Label[5].set_label(Glib::ustring("Saldo Real em Cheque: \t\t"));
				this->Saldos_Saldo[4].pack_start (this->Saldos_Label[5],false,false,0);
				this->Saldos_ESaldo[4].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[4].signal_activate ().connect (sigc::bind(sigc::mem_fun (*this,&PRINCIPAL::tabular),6));
				this->Saldos_Saldo[4].pack_start (this->Saldos_ESaldo[4],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[4],false,false,5);
				this->Saldos_Saldo[5].set_homogeneous (false);
				this->Saldos_Saldo[5].set_spacing (0);
				this->Saldos_Label[6].set_label(Glib::ustring("Saldo Real em Dinheiro: \t"));
				this->Saldos_Saldo[5].pack_start (this->Saldos_Label[6],false,false,0);
				this->Saldos_ESaldo[5].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[5].signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::saldos_calcular),2));
				this->Saldos_Saldo[5].pack_start (this->Saldos_ESaldo[5],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[5],false,false,5);
				this->Saldos_Saldo[6].set_homogeneous (false);
				this->Saldos_Saldo[6].set_spacing (0);
				this->Saldos_Label[7].set_label(Glib::ustring("Saldo Real: \t\t\t\t"));
				this->Saldos_Saldo[6].pack_start (this->Saldos_Label[7],false,false,0);
				this->Saldos_ESaldo[6].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[6].set_editable (false);
				this->Saldos_Saldo[6].pack_start (this->Saldos_ESaldo[6],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[6],false,false,5);
				this->Saldos_Saldo[7].set_homogeneous (false);
				this->Saldos_Saldo[7].set_spacing (0);
				this->Saldos_Label[8].set_label(Glib::ustring("Diferença: \t\t\t\t"));
				this->Saldos_Saldo[7].pack_start (this->Saldos_Label[8],false,false,0);
				this->Saldos_ESaldo[7].set_alignment (Gtk::ALIGN_RIGHT);
				this->Saldos_ESaldo[7].set_editable (false);
				this->Saldos_Saldo[7].pack_start (this->Saldos_ESaldo[7],false,false,0);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[7],false,false,5);
				this->Saldos_Principal.pack_start(this->Saldos_Linhas[2],Gtk::PACK_SHRINK,5);
				this->Saldos_Saldo[8].set_homogeneous (false);
				this->Saldos_Saldo[8].set_spacing (0);
				this->Saldos_Salvar.set_label(Glib::ustring("Salvar"));
				this->Saldos_Salvar.set_sensitive (false);
				this->Saldos_Salvar.signal_clicked ().connect(sigc::mem_fun(*this,&PRINCIPAL::saldos_salvar));
				this->Saldos_Saldo[8].pack_start (this->Saldos_Salvar,false,false,10);
				this->Saldos_Alterar.set_label (Glib::ustring ("Alterar"));
				this->Saldos_Alterar.set_sensitive (false);
				this->Saldos_Alterar.signal_clicked ().connect(sigc::mem_fun(*this,&PRINCIPAL::saldos_salvarA));
				this->Saldos_Saldo[8].pack_start (this->Saldos_Alterar,false,false,10);
				this->Saldos_Principal.pack_start(this->Saldos_Saldo[8],false,false,5);
				this->Saldos.add(this->Saldos_Principal);
				this->Saldos.show_all();
				Gtk::Main::run(this->Saldos);
				}
			else
				{
				this->Saldos.show_all();
				Gtk::Main::run(this->Saldos);
				}
			}
		}
	}

/**
 * Este método carrega a informações dos usuários.
 * \param janela informa qual janela dos usuários será carregada.\n
 * 4 - Usuário Logado.\n
 * 5 - Contas dos Usuários.\n
 */
void PRINCIPAL::m_conta(int janela)
	{
	this->janelas = janela;
  	this->carregar_janela();
	}

/**
 * Este método carrega as janelas de cadastros.
 * \param janela informa qual janela dos usuários será carregada.\n
 * 6 - PRINCIPAL::Cliente.\n
 * 7 - PRINCIPAL::Servico.\n
 */
void PRINCIPAL::m_cadastro(int janela)
	{
	this->janelas = janela;
	this->carregar_janela();
	}

/**
 * \param tab indica qual Gtk::Entry será focada e em qual Gtk::Window.
 */
void PRINCIPAL::tabular(int tab)
	{
	string AUX;
	char *aux;
	float valor;
	int it;
	switch(tab)
		{
		case 1:
			{
			//this->Principal.set_focus(this->Buscar);
			//this->formatar_documento();
			break;
			}
		case 2:
			{
			this->Login.set_focus(this->LoginSE);
			break;
			}
		case 3:
			{
			this->Login.set_focus(*this->LoginOK);
			break;
			}
		case 4:
			{
			this->Novo->set_focus(*this->E_ValNov);
			break;
			}
		case 5:
			{
			this->BaixaB.set_focus(*this->BaixaB_Baixar);
			break;
			}
		case 6:
			{
			AUX.clear();
			AUX = this->Saldos_ESaldo[4].get_text ();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				}
			aux = new char[32];
			strcpy(aux,AUX.c_str());
			valor = atof(valor_formatado(aux,2).c_str());
			cout << "1097 " << valor << endl;
			delete aux;
			aux = new char[32];
			sprintf(aux,"%.02f",valor);
			this->Saldos_ESaldo[4].set_text(casa_milhar(aux,0));
			this->Saldos.set_focus(this->Saldos_ESaldo[5]);
			break;
			}
		case 7:
			{
			this->Saldos.set_focus(this->Saldos_Atualizar);
			break;
			}
		}
	}

/**
 * Nesse método a checagem é utilizada para transformar os caracteres para UpperCase.
 * \param tela indica qual Gtk::Entry será afetada e em qual Gtk::Window.
 */
void PRINCIPAL::checar_nome(int tela)
	{
	string digitado;

 	digitado.clear();
	switch(tela)
		{
		case 1:
			{
			digitado = this->N_ELogin->get_text();
			this->N_ELogin->set_text(ParaMaiusculos(digitado));
			break;
			}
		case 2:
			{
			digitado = this->LoginUE.get_text();
			this->LoginUE.set_text(ParaMaiusculos(digitado));
			break;
			}
		case 4:
			{
			digitado = this->CE_Login.get_text();
			this->CE_Login.set_text(ParaMaiusculos(digitado));
			break;
			}
		case 5:
			{
			digitado = this->E_DescNov->get_text();
			this->E_DescNov->set_text(ParaMaiusculos(digitado));
			break;
			}
		case 6:
			{
			digitado = this->EC_Cliente.get_text();
			this->EC_Cliente.set_text(ParaMaiusculos(digitado));
			this->carregar_dados();
			break;
			}
		case 7:
			{
			digitado = this->EC_Servico.get_text();
			this->EC_Servico.set_text(ParaMaiusculos(digitado));
			this->carregar_dados();
			break;
			}
		case 8:
			{
			digitado = this->E_NomeNov->get_text();
			this->E_NomeNov->set_text(ParaMaiusculos(digitado));
			break;
			}
		case 9:
			{
			digitado = this->E_EndNov->get_text();
			this->E_EndNov->set_text(ParaMaiusculos(digitado));
			break;
			}
		case 10:
			{
			digitado = this->BaixaB_Nome.get_text();
			this->BaixaB_Nome.set_text(ParaMaiusculos(digitado));
			break;
			}
		}
	}

/**
 * Nesse método utilizamos a checagem de digitos é considerado ponto flutuantes.
 * \param e Gtk::Entry que será checada
 * \param opc indica qual Gtk::Entry será checada e em qual Gtk::Window.
 */
void PRINCIPAL::checar_digito(Gtk::Entry * e, int opc)
	{
	string digitado;
	int len;

	digitado.clear();
	switch(opc)
		{
		case 1:
			{
			digitado = e->get_text();
			len = digitado.length();
			if ((digitado[len-1]!= ',') && (!isdigit(digitado[len-1])))
				{
				digitado[len-1] = '\0';
				}
			e->set_text(digitado);
			break;
			}
		case 2:
			{
			digitado = e->get_text();
			len = digitado.length();
			if (!isdigit(digitado[len-1]))
				{
				digitado[len-1] = '\0';
				}
			e->set_text(digitado);
			break;
			}
		}
	}

/**
 * Este método é controlado pelo PRINCIPAL::janelas que indica quais informações
 * devem ser buscadas na base de dados para carregar na devida janela.
 */
void PRINCIPAL::carregar_dados()
	{
	string aux_a, SQL, valor_u, DOC, AUX;
	char *sql, *aux;
	int registro, colunas, i, j, nivel, tipo,it;
	float valor;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
		
	switch(this->janelas)
		{
		case 4:
			{
			this->CE_Nome.set_text(Glib::ustring(this->nome));
			this->CE_Login.set_text(Glib::ustring(this->login));
			this->CE_Senha.set_text(Glib::ustring(this->senha));
			break;
			}
		case 5:
			{
			aux_a.clear();
			SQL.clear();
			SQL = "select cod_fun, nome, u_login, acesso from cadastro.funcionario";
			if (this->EC_Contas.get_text_length() != 0)
				{
				aux_a = EC_Contas.get_text();
				aux_a = " where nome like '" + aux_a + "%'";
				}
			SQL += aux_a + " order by nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			this->conexao->resultado();
			registro = this->conexao->registros;
			colunas = this->conexao->colunas;
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			CTContas.set_model(arvore_ref);
			for (i=0,ir=this->conexao->resultados.begin(); i < registro,ir < this->conexao->resultados.end(); i++, ir++)
				{
				linha = *ir;
				celula = *(arvore_ref->append());
				celula[arvore_reg.cod_func] = atoi(linha.at(0).c_str());
				for (j=0; j < colunas-1; j++)
					{
					celula[arvore_reg.campo[j]]= linha.at(j);
					}
				nivel = atoi(linha.at(3).c_str());
				switch(nivel)
					{
					case 0:
						{
						celula[arvore_reg.campo[3]]= "Acesso Total";
						break;
						}
					case 5:
						{
						celula[arvore_reg.campo[3]]= "Acesso Restrito";
						break;
						}
					case 9:
						{
						celula[arvore_reg.campo[3]]= "Acesso Normal";
						break;
						}
					}
				}
			CTContas.remove_all_columns();
			CTContas.append_column(Glib::ustring("Código"), arvore_reg.campo[0]);
			CTContas.append_column(Glib::ustring("Nome"), arvore_reg.campo[1]);
			CTContas.append_column(Glib::ustring("Login"), arvore_reg.campo[2]);
			CTContas.append_column(Glib::ustring("Nível Acesso"), arvore_reg.campo[3]);
			for(i=0; i < colunas; i++)
				{
				Gtk::TreeView::Column* coluna_temp = CTContas.get_column(i);
				coluna_temp->set_reorderable();	
				}
			delete sql;
			break;
			}
		case 6:
			{
			//Cadastro->Clientes
			aux_a.clear();
			SQL.clear();
			SQL = "select * from cadastro.clientes";
			if (this->EC_Cliente.get_text_length() != 0)
				{
				aux_a = this->EC_Cliente.get_text();
				aux_a = " where nome like '" + aux_a + "%'";
				}
			SQL += aux_a + " order by credito desc, nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				this->conexao->resultado();
				registro = this->conexao->registros;
				colunas = this->conexao->colunas;
				arvore_ref = Gtk::ListStore::create(arvore_reg);
				this->CT_Cliente.set_model(arvore_ref);
				for (ir = this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
					{
					linha = *ir;
					celula = *(arvore_ref->append());
					celula[arvore_reg.cod_cli] = atoi(linha.at(0).c_str());
					celula[arvore_reg.campo[0]]= linha.at(0);
					tipo = atoi(linha.at(4).c_str());
					if (tipo == 2)
						{
						celula[arvore_reg.campo[1]]= Glib::ustring("Jurídica");
						aux = new char[21];
						strcpy(aux,linha.at(3).c_str());
						DOC.clear();
						if (strlen(aux) == 14)
						  	{
							DOC = masc_doc(aux,2,2);
							}
						else
							{
							DOC.append(aux);
							}
						delete aux;
						}
					else
						{
						celula[arvore_reg.campo[1]]= Glib::ustring("Física");
						aux = new char[21];
						strcpy(aux,linha.at(3).c_str());
						DOC.clear();
						if (strlen(aux) == 11)
						  	{
							DOC = masc_doc(aux,1,2);
							}
						else
							{
							DOC.append(aux);
							}
						delete aux;
						}
					celula[arvore_reg.campo[2]]= linha.at(1);
					celula[arvore_reg.campo[3]]= DOC;
					if (linha.at(5).compare("t") == 0)
						{
						celula[arvore_reg.credito] = true;
						}
					else
						{
						celula[arvore_reg.credito] = false;
						}
					if (linha.at(6).compare("t") == 0)
						{
						celula[arvore_reg.sub_issqn] = true;
						}
					else
						{
						celula[arvore_reg.sub_issqn] = false;
						}
					}
				this->CT_Cliente.remove_all_columns();
				this->CT_Cliente.append_column(Glib::ustring("Código"), arvore_reg.campo[0]);
				this->CT_Cliente.append_column(Glib::ustring("Tipo"), arvore_reg.campo[1]);
				this->CT_Cliente.append_column(Glib::ustring("Nome"), arvore_reg.campo[2]);
				this->CT_Cliente.append_column(Glib::ustring("Documento"), arvore_reg.campo[3]);
				this->CT_Cliente.append_column(Glib::ustring("Crédito"), arvore_reg.credito);
				this->CT_Cliente.append_column(Glib::ustring("Sub ISSQN"), arvore_reg.sub_issqn);
				for(i=0; i < 6; i++)
					{
					Gtk::TreeView::Column* coluna_temp = this->CT_Cliente.get_column(i);
					coluna_temp->set_reorderable();
					}
				}
			break;
			}
		case 7:
			{
			//Cadastro->Serviços
			aux_a.clear();
			SQL.clear();
			SQL = "select * from cadastro.servicos";
			if (this->EC_Servico.get_text_length() != 0)
				{
				aux_a = this->EC_Servico.get_text();
				aux_a = " where descricao like '" + aux_a + "%'";
				}
			SQL += aux_a + " order by e_s, codigo";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			//Parei aqui 'conexao->'
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				this->conexao->resultado();
				registro = this->conexao->registros;
				colunas = this->conexao->colunas;
				arvore_ref = Gtk::ListStore::create(arvore_reg);
				this->CT_Servico.set_model(arvore_ref);
				for (i=0,ir=this->conexao->resultados.begin(); i < registro,ir < this->conexao->resultados.end(); i++,ir++)
					{
					linha = *ir;
					celula = *(arvore_ref->append());
					celula[arvore_reg.cod_serv] = atoi(linha.at(0).c_str());
					celula[arvore_reg.campo[0]]= linha.at(2);
					tipo = atoi(linha.at(1).c_str());
					if (tipo == 1)
						{
						celula[arvore_reg.campo[1]]= "Entrada";
						}
					else if (tipo == 2)
						{
						celula[arvore_reg.campo[1]]= "Saída";
						}
					celula[arvore_reg.campo[2]]= linha.at(3);
					valor_u.clear();
					valor_u = linha.at(4);
					it = valor_u.find(".");
					if (it!=string::npos)
	  					{
						valor_u.replace(it,1,",");
						}
					valor = atof(valor_u.c_str());
					//cout << __LINE__ << " " << valor << endl;
					celula[arvore_reg.campo_n] = valor;
					if (linha.at(5).compare("t") == 0)
						{
						celula[arvore_reg.imposto] = true;
						}
					else
						{
						celula[arvore_reg.imposto] = false;
						}
					}
				this->CT_Servico.remove_all_columns();
				this->CT_Servico.append_column(Glib::ustring("Código"), arvore_reg.campo[0]);
				this->CT_Servico.append_column(Glib::ustring("Tipo"), arvore_reg.campo[1]);
				this->CT_Servico.append_column(Glib::ustring("Descrição"), arvore_reg.campo[2]);
				this->CT_Servico.append_column_numeric(Glib::ustring("Valor R$"), arvore_reg.campo_n,"%.2f");
				this->CT_Servico.append_column(Glib::ustring("F10"), arvore_reg.imposto);
				for(i=0; i < 3; i++)
					{
					Gtk::TreeView::Column* coluna_temp = this->CT_Servico.get_column(i);
					coluna_temp->set_reorderable();
					}
				}
			delete sql;
			break;
			}
		}
	}	

/**
 * Acionado pelo PRINCIPAL::CC_Senha ele habilita e desabilita a visualização da
 * senha do usuário logado na tela PRINCIPAL::Conta.
 */
void PRINCIPAL::mostrar_senha()
	{
	if (this->CC_Senha.get_active() == 1)
		{
		this->CE_Senha.set_visibility(true);
		this->CE_Senha.unset_invisible_char();
		}
	else if (this->CC_Senha.get_active() == 0)
		{
		this->CE_Senha.set_visibility(false);
		this->CE_Senha.set_invisible_char('$');
		}
	}

/**
 * Este método utilizada o PRINCIPAL::janelas para carregar as informações no PRINCIPAL::Editar.
 */
void PRINCIPAL::editar_dados()
	{
	string codigo, SQL, auxilio;
	char *aux, *sql;
	int n_aces, n_sel, n_jur, it;
	Gtk::Fixed *N_Tela;
	Gtk::Label *L_Novo, *Aviso;
	Gtk::Button *B_Novo;
	Gtk::RadioButton::Group Imposto, ISSQN;
	Gtk::RadioButton *S_Imp, *S_SubISSQN;
	Gtk::HBox *HBOX;
	Gtk::VBox *VBOX;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

  	this->acao=2;
	switch(this->janelas)
		{
		case 4:
			{
			this->CE_Nome.set_sensitive(true);
			this->CE_Login.set_sensitive(true);
		  	this->CB_Alt->set_sensitive(false);
			this->CB_Salvar->set_sensitive(true);
			this->Conta.set_focus(this->CE_Nome);
			break;
			}
		case 5:
			{
			this->TBE_Contas.set_sensitive(false);
			this->TBD_Contas.set_sensitive(false);
			aux = new char[10];
			itoa(this->cod_sel,aux,10);
			codigo.clear();
			codigo = aux;
			SQL.clear(); 
			SQL = "select * from cadastro.funcionario where cod_fun="+codigo;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 2)
				{
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				codigo = "Código Selecionado: <b>" + codigo + "</b>";
				this->Editar = new Gtk::Window();
				this->Editar->set_title(Glib::ustring("Editar Conta Selecionada"));
				this->Editar->set_size_request(400,200);
				this->Editar->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Editar->set_position(Gtk::WIN_POS_CENTER);
				this->Editar->set_icon(this->ponteiro_icon);
				this->Editar->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				N_Tela = new Gtk::Fixed();
				L_Novo = new Gtk::Label();
				L_Novo->set_markup(codigo);
				N_Tela->put(*L_Novo,10,10);
				L_Novo = new Gtk::Label("Nome: ");
				auxilio.clear();
				auxilio = linha.at(1);
				this->N_ENome = new Gtk::Entry();
				this->N_ENome->set_text(Glib::ustring(auxilio));
				this->N_ENome->set_size_request(310,28);
				N_Tela->put(*L_Novo,10,40);
				N_Tela->put(*this->N_ENome,80,35);
				L_Novo = new Gtk::Label("Login: ");
			  	auxilio.clear();
				auxilio = linha.at(2);
				this->N_ELogin = new Gtk::Entry();
				this->N_ELogin->set_text(Glib::ustring(auxilio));
				this->N_ELogin->set_size_request(120,28);
  				this->N_ELogin->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),1));
				this->N_ELogin->set_max_length(10);
				Aviso = new Gtk::Label();
				Aviso->set_markup(Glib::ustring("<b>Máximo 10 caracteres</b>"));
				N_Tela->put(*L_Novo,10,70);
				N_Tela->put(*this->N_ELogin,80,65);
				N_Tela->put(*Aviso,210,70);
				L_Novo = new Gtk::Label(Glib::ustring("Nível Acesso:"));
				N_CNivel = new Gtk::ComboBoxText();
				N_Tela->put(*L_Novo,10,100);
				N_Tela->put(*N_CNivel,110,95);
				/* Dados do Nível de Acesso */
				this->N_CNivel->clear();
				this->arvore_ref = Gtk::ListStore::create(this->arvore_reg);
				this->N_CNivel->set_model(this->arvore_ref);
				this->celula = *(this->arvore_ref->append());
				this->celula[this->arvore_reg.cod_acesso] = 0;
				this->celula[this->arvore_reg.descricao] = "Acesso Total";
				this->celula = *(this->arvore_ref->append());
				this->celula[this->arvore_reg.cod_acesso] = 5;
				this->celula[this->arvore_reg.descricao] = "Acesso Restrito";
				this->celula = *(this->arvore_ref->append());
				this->celula[this->arvore_reg.cod_acesso] = 9;
				this->celula[this->arvore_reg.descricao] = "Acesso Normal";
				n_aces = atoi(linha.at(4).c_str());
				n_sel = 0;
				if (n_aces == 5)
					{
					n_sel = 1;
					}
				else if (n_aces == 9)
					{
					n_sel = 2;
					}
				this->N_CNivel->set_active(n_sel);
				/*Dados do nível de Acesso */
				B_Novo = new Gtk::Button(Gtk::Stock::SAVE);
				B_Novo->set_size_request(100,28);
				B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
				N_Tela->put(*B_Novo,20,150);
				B_Novo = new Gtk::Button(Gtk::Stock::QUIT);
				B_Novo->set_size_request(100,28);
				B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				N_Tela->put(*B_Novo,130,150);
				B_Novo = new Gtk::Button(Gtk::Stock::DIALOG_AUTHENTICATION);
				B_Novo->set_label("_Mudar Senha");
				B_Novo->set_size_request(100,28);
				B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::mudar_senha));
				N_Tela->put(*B_Novo,240,150);
				this->Editar->add(*N_Tela);
			
				this->Editar->show_all();
				Gtk::Main::run(*this->Editar);
				}
			delete aux;
			break;
			}
		case 6:
			{
			this->TBE_Cliente.set_sensitive(false);
			this->TBD_Cliente.set_sensitive(false);
			aux = new char[10];
			itoa(this->cod_sel,aux,10);
			codigo.clear();
			codigo = aux;
			delete aux;
			SQL.clear(); 
			SQL = "select * from cadastro.clientes where cod_cli="+codigo;
			//cout << SQL << endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 2)
				{
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				this->Editar = new Gtk::Window();
				this->Editar->set_title(Glib::ustring("Cadastro de Clientes::Edição"));
				this->Editar->set_size_request(400,235);
				this->Editar->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				VBOX = new Gtk::VBox(false,0);
				S_Imp = new Gtk::RadioButton(Glib::ustring("Não Crédito"));
				Imposto = S_Imp->get_group();
				this->Imp = new Gtk::RadioButton(Imposto,Glib::ustring("Crédito"));
				if (linha.at(5).compare("t") == 0)
					{
					this->Imp->set_active (true);
					S_Imp->set_active (false);
					}
				else
					{
					this->Imp->set_active (false);
					S_Imp->set_active (true);
					}
				HBOX = new Gtk::HBox(false,0);
				HBOX->pack_start (*this->Imp,false,false,0);
				HBOX->pack_start (*S_Imp,false,false,0);
				VBOX->pack_start(*HBOX,false,false,0);
				S_SubISSQN = new Gtk::RadioButton(Glib::ustring("Não Sub ISSQN"));
				ISSQN = S_SubISSQN->get_group();
				this->SubISSQN = new Gtk::RadioButton(ISSQN,Glib::ustring("Sub ISSQN"));
				if (linha.at(6).compare("t") == 0)
					{
					this->SubISSQN->set_active (true);
					S_SubISSQN->set_active (false);
					}
				else
					{
					this->SubISSQN->set_active (false);
					S_SubISSQN->set_active (true);
					}
				HBOX = new Gtk::HBox(false,0);
				HBOX->pack_start (*this->SubISSQN,false,false,0);
				HBOX->pack_start (*S_SubISSQN,false,false,0);
				VBOX->pack_start(*HBOX,false,false,0);
				N_Tela = new Gtk::Fixed();
				L_Novo = new Gtk::Label();
				auxilio.clear();
				auxilio = "Natureza: <b>Pessoa ";
				n_jur = atoi(linha.at(4).c_str());
				if (n_jur == 2)
					{
					auxilio += "Jurídica</b>";
					}
				else
					{
					auxilio += "Física</b>";
					}
				L_Novo->set_markup(Glib::ustring(auxilio));
				N_Tela->put(*L_Novo,10,10);
				L_Novo = new Gtk::Label();
				auxilio.clear();
				auxilio = "Código: <b>";
				auxilio += linha.at(0);
				auxilio += "</b>";
				L_Novo->set_markup(Glib::ustring(auxilio));
				N_Tela->put(*L_Novo,10,40);
				L_Novo = new Gtk::Label(Glib::ustring("Nome: "));
				this->E_NomeNov = new Gtk::Entry();
				this->E_NomeNov->set_size_request(300,28);
				this->E_NomeNov->set_max_length(100);
				this->E_NomeNov->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),8));
				auxilio.clear();
				auxilio = linha.at(1);
				this->E_NomeNov->set_text(Glib::ustring(auxilio));
				N_Tela->put(*L_Novo,10,70);
				N_Tela->put(*this->E_NomeNov,80,65);
				L_Novo = new Gtk::Label(Glib::ustring("Endereço: "));
				this->E_EndNov = new Gtk::Entry();
				this->E_EndNov->set_size_request(300,28);
				this->E_EndNov->set_max_length(200);
				this->E_EndNov->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),9));
				auxilio.clear();
				auxilio = linha.at(2);
				this->E_EndNov->set_text(Glib::ustring(auxilio));
				N_Tela->put(*L_Novo,10,100);
				N_Tela->put(*this->E_EndNov,80,95);
				L_Novo = new Gtk::Label("Documento: ");
				this->E_DocNov = new Gtk::Entry();
				this->E_DocNov->set_size_request(150,28);
				this->E_DocNov->set_max_length(20);
				this->E_DocNov->signal_changed().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&PRINCIPAL::checar_documento2),1,n_jur));
				auxilio.clear();
				auxilio = linha.at(3);
				this->E_DocNov->set_text(Glib::ustring(auxilio));
				N_Tela->put(*L_Novo,10,130);
				N_Tela->put(*this->E_DocNov,100,125);
				B_Novo = new Gtk::Button(Gtk::Stock::SAVE);
				B_Novo->set_size_request(120,28);
				B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
				N_Tela->put(*B_Novo,20,160);
				B_Novo = new Gtk::Button(Gtk::Stock::CANCEL);
				B_Novo->set_size_request(120,28);
				B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				N_Tela->put(*B_Novo,150,160);
				VBOX->pack_start (*N_Tela,false,false,0);
				this->Editar->add(*VBOX);

				this->Editar->show_all();
				Gtk::Main::run(*this->Editar);
				}
			delete sql;
			break;
			}
		case 7:
			{
			this->TBE_Servico.set_sensitive(false);
			this->TBD_Servico.set_sensitive(false);
			aux = new char[10];
			itoa(this->cod_sel,aux,10);
			codigo.clear();
			codigo = aux;
			delete aux;
			SQL.clear(); 
			SQL = "select * from cadastro.servicos where cod_serv="+codigo;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 2)
				{
				this->conexao->resultado();
				ir = this->conexao->resultados.begin();
				linha = *ir;
				this->Editar = new Gtk::Window();
				this->Editar->set_title(Glib::ustring("Cadastro de Serviços::Edição"));
				this->Editar->set_size_request(400,180);
				this->Editar->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				VBOX = new Gtk::VBox(false,0);
				S_Imp = new Gtk::RadioButton(Glib::ustring("Sem Imposto"));
				Imposto = S_Imp->get_group();
				this->Imp = new Gtk::RadioButton(Imposto,Glib::ustring("Imposto"));
				if (linha.at(5).compare("t") == 0)
					{
					this->Imp->set_active (true);
					S_Imp->set_active (false);
					}
				else
					{
					this->Imp->set_active (false);
					S_Imp->set_active (true);
					}
				HBOX = new Gtk::HBox(false,0);
				HBOX->pack_start (*this->Imp,false,false,0);
				HBOX->pack_start (*S_Imp,false,false,0);
				VBOX->pack_start(*HBOX,false,false,0);
				N_Tela = new Gtk::Fixed();
				L_Novo = new Gtk::Label(Glib::ustring("Tipo Serviço:"));
				this->CBT_Novo = new Gtk::ComboBoxText();
				N_Tela->put(*L_Novo,10,10);
				N_Tela->put(*this->CBT_Novo,110,5);
				/* Dados do Tipo de Serviço */
				this->CBT_Novo->clear();
				arvore_ref = Gtk::ListStore::create(arvore_reg);
				this->CBT_Novo->set_model(arvore_ref);
				celula = *(arvore_ref->append());
				celula[arvore_reg.tipo_serv] = 0;
				celula[arvore_reg.descricao] = "Selecione...";
				celula = *(arvore_ref->append());
				celula[arvore_reg.tipo_serv] = 1;
				celula[arvore_reg.descricao] = "Entrada";
				celula = *(arvore_ref->append());
				celula[arvore_reg.tipo_serv] = 2;
				celula[arvore_reg.descricao] = Glib::ustring("Saída");
				n_sel = atoi(linha.at(1).c_str());
				this->CBT_Novo->set_active(n_sel);
				/*Dados do Tipo de Serviço */
				//this->CBT_Novo->signal_changed().connect(sigc::mem_fun(*this,&PRINCIPAL::sel_tipo));
				this->CBT_Novo->set_sensitive(false);
				codigo.clear();
				codigo = "Código: <b>";
				codigo += linha.at(2);
				codigo += "</b>";
				this->L_CodNov = new Gtk::Label();
				this->L_CodNov->set_markup(Glib::ustring(codigo));
				N_Tela->put(*this->L_CodNov,10,40);
				L_Novo = new Gtk::Label(Glib::ustring("Descrição: "));
				N_Tela->put(*L_Novo,10,70);
				this->E_DescNov = new Gtk::Entry();
				this->E_DescNov->set_size_request(290,28);
				this->E_DescNov->set_max_length(100);
				this->E_DescNov->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),5));
				this->E_DescNov->signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),4));
				auxilio.clear();
				auxilio = linha.at(3);
				this->E_DescNov->set_text(Glib::ustring(auxilio));
				N_Tela->put(*this->E_DescNov,100,65);
				L_Novo = new Gtk::Label(Glib::ustring("Valor R$: "));
				N_Tela->put(*L_Novo,10,100);
				this->E_ValNov = new Gtk::Entry();
				this->E_ValNov->set_size_request(180,28);
				this->E_ValNov->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),this->E_ValNov,1));
				auxilio.clear();
				auxilio = linha.at(4);
				it = auxilio.find(".");
				if (it!=string::npos)
  					{
					auxilio.replace(it,1,",");
					}
				this->E_ValNov->set_text(auxilio);
				N_Tela->put(*this->E_ValNov,100,95);
				B_Novo = new Gtk::Button(Gtk::Stock::OK);
				B_Novo->set_size_request(120,28);
				B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
				N_Tela->put(*B_Novo,20,125);
				B_Novo = new Gtk::Button(Gtk::Stock::CANCEL);
				B_Novo->set_size_request(120,28);
				B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),7));
				N_Tela->put(*B_Novo,150,125);
				VBOX->pack_start (*N_Tela,false,false,0);
				this->Editar->add(*VBOX);
				
				this->Editar->show_all();
				Gtk::Main::run(*this->Editar);
				}
			delete sql;
			break;
			}
		}
	}

/**
 * Este método grava informações alteradas do usuário logado.
 */
void PRINCIPAL::gravar_alterado()
	{
	string SQL;
  	char *sql;
	switch(this->janelas)
		{
		case 4:
			{
			SQL.clear();
			SQL = "update cadastro.funcionario set nome='" + this->CE_Nome.get_text();
			SQL += "',u_login='" + this->CE_Login.get_text();
			SQL += "' where cod_fun=" + this->cod_func;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 1)
				{
				this->nome = this->CE_Nome.get_text();
				this->login = this->CE_Login.get_text();
				}
			this->CE_Nome.set_sensitive(false);
			this->CE_Login.set_sensitive(false);
			this->CB_Salvar->set_sensitive(false);
			this->CB_Alt->set_sensitive(true);
			this->carregar_dados();
			break;
			}
		}
	}

/**
 * Utiliza um Gtk::Dialog para checar a senha antiga e salvar a nova senha na base de dados.
 */
void PRINCIPAL::mudar_senha()
	{
	int resposta;
	string SQL, senha_n;
	char *sql, *aux;
	switch(this->janelas)
		{
		case 4:
			{
			Gtk::Dialog *Senha = new Gtk::Dialog(Glib::ustring("Alteração de Senha"),this->Conta,true);
			Senha->set_size_request(230,150);
			Senha->add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
			Senha->add_button(Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL);
			Gtk::Fixed *FD_Senha = new Gtk::Fixed();
			Senha->get_vbox()->pack_start(*FD_Senha,Gtk::PACK_SHRINK);
			Gtk::Label *LD_SenhaA = new Gtk::Label("Senha Atual:");
			Gtk::Entry *ED_SenhaA = new Gtk::Entry();
		  	ED_SenhaA->set_visibility(false);
			ED_SenhaA->set_invisible_char('$');
			ED_SenhaA->set_size_request(120,28);
			ED_SenhaA->set_max_length(10);
			FD_Senha->put(*LD_SenhaA,5,10);
			FD_Senha->put(*ED_SenhaA,100,5);
			Gtk::Label *LD_SenhaN = new Gtk::Label("Nova Senha: ");
			Gtk::Entry *ED_SenhaN = new Gtk::Entry();
			ED_SenhaN->set_visibility(false);
			ED_SenhaN->set_invisible_char('$');
			ED_SenhaN->set_size_request(120,28);
			ED_SenhaN->set_max_length(10);
			FD_Senha->put(*LD_SenhaN,5,40);
			FD_Senha->put(*ED_SenhaN,100,35);
			Gtk::Label *LD_SenhaC = new Gtk::Label(Glib::ustring("Confirmação: "));
			Gtk::Entry *ED_SenhaC = new Gtk::Entry();
			ED_SenhaC->set_visibility(false);
			ED_SenhaC->set_invisible_char('$');
			ED_SenhaC->set_size_request(120,28);
			ED_SenhaC->set_max_length(10);
			FD_Senha->put(*LD_SenhaC,5,70);
			FD_Senha->put(*ED_SenhaC,100,65);
			Senha->set_focus(*ED_SenhaA);
			Senha->show_all();
			resposta = Senha->run();
			switch(resposta)
				{
				case Gtk::RESPONSE_OK:
					{
					if (this->senha.compare(ED_SenhaA->get_text()) == 0)
						{
						senha_n = ED_SenhaN->get_text();
						if (senha_n.compare(ED_SenhaC->get_text()) == 0)
							{
							SQL.clear();
							SQL = "update cadastro.funcionario set senha=md5('";
				  			SQL += senha_n + "') where cod_fun="+this->cod_func;
							sql = new char[SQL.length()+1];
						  	strcpy(sql,SQL.c_str());
							//cout << sql << endl;
							this->conexao->executar(sql);
						  	switch (this->conexao->query_result)
								{
								case 1:
									{
									this->senha = senha_n;
									break;
									}
								case 3:
									{
									cout << this->conexao->mensagem << endl;
									break;
									}
								}
							this->carregar_dados();
							}
						else
							{
							Gtk::MessageDialog dialog(*Senha, Glib::ustring("Senha Confirmação"), false, Gtk::MESSAGE_ERROR);
							dialog.set_secondary_text(Glib::ustring("A senha de confirmação digitada não confere com a sua senha nova!"));
							dialog.run();
							}
						}
					else
					  	{
						Gtk::MessageDialog dialog(*Senha, Glib::ustring("Senha Atual"), false, Gtk::MESSAGE_ERROR);
						dialog.set_secondary_text(Glib::ustring("A senha atual digitada não confere com a sua senha!"));
						dialog.run();
						}								
					Senha->hide();
					break;
					}
				case Gtk::RESPONSE_CLOSE:
				case Gtk::RESPONSE_CANCEL:
					{
					Senha->hide();
					break;
					}
				}
			break;
			}
		case 5:
			{
			Gtk::Dialog *Senha = new Gtk::Dialog(Glib::ustring("Alteração de Senha"),*this->Editar,true);
			Senha->set_size_request(230,110);
			Senha->add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
			Senha->add_button(Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL);
			Gtk::Fixed *FD_Senha = new Gtk::Fixed();
			Senha->get_vbox()->pack_start(*FD_Senha,Gtk::PACK_SHRINK);
			Gtk::Label *LD_SenhaN = new Gtk::Label("Nova Senha: ");
			Gtk::Entry *ED_SenhaN = new Gtk::Entry();
			ED_SenhaN->set_visibility(false);
			ED_SenhaN->set_invisible_char('$');
			ED_SenhaN->set_size_request(120,28);
			ED_SenhaN->set_max_length(10);
			FD_Senha->put(*LD_SenhaN,5,10);
			FD_Senha->put(*ED_SenhaN,100,5);
			Gtk::Label *LD_SenhaC = new Gtk::Label(Glib::ustring("Confirmação: "));
			Gtk::Entry *ED_SenhaC = new Gtk::Entry();
			ED_SenhaC->set_visibility(false);
			ED_SenhaC->set_invisible_char('$');
			ED_SenhaC->set_size_request(120,28);
			ED_SenhaC->set_max_length(10);
			FD_Senha->put(*LD_SenhaC,5,40);
			FD_Senha->put(*ED_SenhaC,100,35);
			Senha->set_focus(*ED_SenhaN);
			Senha->show_all();
			resposta = Senha->run();
			switch(resposta)
				{
				case Gtk::RESPONSE_OK:
					{
					senha_n = ED_SenhaN->get_text();
					if (senha_n.compare(ED_SenhaC->get_text()) == 0)
						{
						SQL.clear();
						SQL = "update cadastro.funcionario set senha=md5('";
				  		SQL += senha_n + "') where cod_fun=";
						aux = new char[10];
						itoa(this->cod_sel,aux,10);
						SQL.append(aux);
						delete aux;
						sql = new char[SQL.length()+1];
					  	strcpy(sql,SQL.c_str());
						//cout << sql << endl;
						this->conexao->executar(sql);
					  	switch (this->conexao->query_result)
							{
							case 1:
								{
								aux = new char[10];
								itoa(this->cod_sel,aux,10);
								if (this->cod_func.compare(aux) == 0)
									{
									this->senha = senha_n;
									}
								delete aux;
								break;
								}
							case 3:
								{
								cout << this->conexao->mensagem << endl;
								break;
								}
							}
						this->carregar_dados();
						}
					else
						{
						Gtk::MessageDialog dialog(*Senha, Glib::ustring("Senha Confirmação"), false, Gtk::MESSAGE_ERROR);
						dialog.set_secondary_text(Glib::ustring("A senha de confirmação digitada não confere com a sua senha nova!"));
						dialog.run();
						}
					Senha->hide();
					break;
					}
				case Gtk::RESPONSE_CLOSE:
				case Gtk::RESPONSE_CANCEL:
					{
					Senha->hide();
					break;
					}
				}
			break;
			}
		}
	}

/**
 * \param path caminho do tipo Gtk::TreeModel::Path.
 * \param column coluna do tipo Gtk::TreeView::Column.
 */
void PRINCIPAL::selecionado(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column)
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	int i;

	contador = arvore_ref->get_iter(path);
	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			switch(this->janelas)
				{
				case 5:
					{
					this->cod_sel = registro[arvore_reg.cod_func];
					this->TBE_Contas.set_sensitive(true);
					this->TBD_Contas.set_sensitive(true);
					break;
					}
				case 6:
					{
					this->cod_sel = registro[arvore_reg.cod_cli];
					this->TBE_Cliente.set_sensitive(true);
					this->TBD_Cliente.set_sensitive(true);
					break;
					}
				case 7:
					{
					this->cod_sel = registro[arvore_reg.cod_serv];
					this->TBE_Servico.set_sensitive(true);
					this->TBD_Servico.set_sensitive(true);
					break;
					}
				}
			}
		}
	}

/**
 * Este método é controlado por PRINCIPAL::janelas que indica qual o código que
 * deve retornar, sendo que são referentes à: usuários, clientes e serviços. Vale
 * observar que esse código não são controlados pelo banco de dados, ou seja, devem
 * ser calculados manualmente, por isso a necessidade deste método.
 */
string PRINCIPAL::novo_codigo()
	{
	string SQL;
	char *sql,*aux;
	string retorno;
	int i,chk,cod,total;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	sql = new char[100];
	chk = 0;
	switch(this->janelas)
		{
		case 5:
			{
			strcpy(sql,"select cod_fun from cadastro.funcionario order by cod_fun");
			break;
			}
		case 6:
			{
			chk = 1;
			sprintf(sql,"select cod_cli from cadastro.clientes order by cod_cli");
			break;
			}
		case 7:
			{
			sprintf(sql,"select codigo from cadastro.servicos where e_s=%d order by codigo",this->e_s);
			this->Novo->set_focus(*this->E_DescNov);
			break;
			}
		}
	this->conexao->executar(sql);
	delete sql;
	total = this->conexao->registros;
	this->conexao->resultado();
	for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
		{
		linha = *ir;
		cod = atoi(linha.at(0).c_str());
		if (chk != cod)
			{
			break;
			}
		chk++;
		}
	aux = new char[32];
	sprintf(aux,"%d",chk);
	retorno.clear();
	retorno.append(aux);
  	delete aux;
	return (retorno);
	}

/**
 * \param tela informa para o método qual Gtk::Window está encontra-se o Gtk::Entry
 * está contido.
 */
void PRINCIPAL::checar_documento(int tela)
	{
	string digitado;
	int tipo, len, digitos[14],dv[2],i,mult;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;

	switch(tela)
		{
		case 1:
			{
			contador = this->CBT_Novo->get_active();
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					tipo = registro[this->arvore_reg.tipo_jur];
					}
				}
			switch(tipo)
				{
				default:
					{
					Gtk::MessageDialog dialog(*this->Novo, Glib::ustring("Checagem de Documento"), false, Gtk::MESSAGE_WARNING);
					dialog.set_message(Glib::ustring("Selecione a Natureza Jurídica"));
					dialog.run();
					this->E_DocNov->set_text("");
					break;
					}
				case 1:
					{
					this->E_DocNov->set_max_length(11);
					digitado = this->E_DocNov->get_text();
					len = digitado.length()-1;
					if (!isdigit(digitado[len]))
						{
						digitado[len] = '\0';
						}
					if (digitado.length() == 11)
						{
						dv[0] = dv[1] = 0;
						for (i=0; i < 11; i++)
							{
							digitos[i] = digitado[i] - 48;
							if (i < 9)
								{
								dv[0] = dv[0] + digitos[i]*(i+1);
								}
							if (i < 10)
								{
								dv[1] = dv[1] + digitos[i]*i;
								}	
							}
						//cout << dv[0] << " - " << dv[1] << endl;
						dv[0] =  dv[0] % 11;
						dv[1] =  dv[1] % 11;
						//cout << dv[0] << "=" << digitos[9] << endl;
						//cout << dv[1] << "=" << digitos[10] << endl;
						if (dv[0] == 10)
							{
							dv[0] = 0;
							}
						if (dv[1] == 10)
							{
							dv[1] = 0;
							}
						if ((dv[0] != digitos[9])||(dv[1] != digitos[10]))
							{
							Gtk::MessageDialog dialog(*this->Novo, Glib::ustring("Checagem de CPF"), false, Gtk::MESSAGE_ERROR);
							dialog.set_message(Glib::ustring("CPF inválido"));
							dialog.run();
							this->Novo->set_focus(*this->E_DocNov);
							}
						}
					this->E_DocNov->set_text(digitado);
					break;
					}
				case 2:
					{
					this->E_DocNov->set_max_length(14);
					digitado = this->E_DocNov->get_text();
					len = digitado.length()-1;
					if (!isdigit(digitado[len]))
						{
						digitado[len] = '\0';
						}
					if (digitado.length() == 14)
						{
						dv[0] = dv[1] = 0;
						for (i=0; i < 14; i++)
							{
							digitos[i] = digitado[i] - 48;
							if (i < 12)
								{
								mult = 6+i;
								if (mult >= 10)
									{
									mult = mult - 8;
									}
								dv[0] = dv[0] + digitos[i]*mult;
								//cout << digitos[i] << "*" << mult  << "=" << digitos[i]*mult << endl;
								//cout << dv[0] << endl;
								}
							if (i < 13)
								{
								mult = 5+i;
								if (mult >= 10)
									{
									mult = mult - 8;
									}										
								dv[1] = dv[1] + digitos[i]*mult;
								}	
							}
						//cout << dv[0] << " - " << dv[1] << endl;
						dv[0] =  dv[0] % 11;
						dv[1] =  dv[1] % 11;
						//cout << dv[0] << "=" << digitado[12] << endl;
						//cout << dv[1] << "=" << digitado[13] << endl;
						if (dv[0] == 10)
							{
							dv[0] = 0;
							}
						if (dv[1] == 10)
							{
							dv[1] = 0;
							}
						if ((dv[0] != digitos[12])||(dv[1] != digitos[13]))
							{
							Gtk::MessageDialog dialog(*this->Novo, Glib::ustring("Checagem de CNPJ"), false, Gtk::MESSAGE_ERROR);
							dialog.set_message(Glib::ustring("CNPJ inválido"));
							dialog.run();
							this->Novo->set_focus(*this->E_DocNov);
							}
						}
					this->E_DocNov->set_text(digitado);
					break;
					}
				}
			break;
			}
		}
	}

/**
 * \param tela informa para o método qual Gtk::Window está encontra-se o Gtk::Entry
 * está contido.
 * \param tipo informa qual o tipo de documento que será checado.\n
 * 1 - CNPJ
 * 2 - CPF
 */
void PRINCIPAL::checar_documento2(int tela, int tipo)
	{
	string digitado;
	int len, digitos[14],dv[2],i,mult;

	switch(tela)
		{
		case 1:
			{
			switch(tipo)
				{
				default:
					{
					Gtk::MessageDialog dialog(*this->Editar, Glib::ustring("Checagem de Documento"), false, Gtk::MESSAGE_WARNING);
					dialog.set_message(Glib::ustring("Selecione a Natureza Jurídica"));
					dialog.run();
					this->E_DocNov->set_text("");
					break;
					}
				case 1:
					{
					this->E_DocNov->set_max_length(11);
					digitado = this->E_DocNov->get_text();
					len = digitado.length()-1;
					if (!isdigit(digitado[len]))
						{
						digitado[len] = '\0';
						}
					if (digitado.length() == 11)
						{
						dv[0] = dv[1] = 0;
						for (i=0; i < 11; i++)
							{
							digitos[i] = digitado[i] - 48;
							if (i < 9)
								{
								dv[0] = dv[0] + digitos[i]*(i+1);
								}
							if (i < 10)
								{
								dv[1] = dv[1] + digitos[i]*i;
								}	
							}
						//cout << dv[0] << " - " << dv[1] << endl;
						dv[0] =  dv[0] % 11;
						dv[1] =  dv[1] % 11;
						//cout << dv[0] << "=" << digitos[9] << endl;
						//cout << dv[1] << "=" << digitos[10] << endl;
						if (dv[0] == 10)
							{
							dv[0] = 0;
							}
						if (dv[1] == 10)
							{
							dv[1] = 0;
							}
						if ((dv[0] != digitos[9])||(dv[1] != digitos[10]))
							{
							Gtk::MessageDialog dialog(*this->Editar, Glib::ustring("Checagem de CPF"), false, Gtk::MESSAGE_ERROR);
							dialog.set_message(Glib::ustring("CPF inválido"));
							dialog.run();
							this->Editar->set_focus(*this->E_DocNov);
							}
						}
					this->E_DocNov->set_text(digitado);
					break;
					}
				case 2:
					{
					this->E_DocNov->set_max_length(14);
					digitado = this->E_DocNov->get_text();
					len = digitado.length()-1;
					if (!isdigit(digitado[len]))
						{
						digitado[len] = '\0';
						}
					if (digitado.length() == 14)
						{
						dv[0] = dv[1] = 0;
						for (i=0; i < 14; i++)
							{
							digitos[i] = digitado[i] - 48;
							if (i < 12)
								{
								mult = 6+i;
								if (mult >= 10)
									{
									mult = mult - 8;
									}
								dv[0] = dv[0] + digitos[i]*mult;
								//cout << digitos[i] << "*" << mult  << "=" << digitos[i]*mult << endl;
								//cout << dv[0] << endl;
								}
							if (i < 13)
								{
								mult = 5+i;
								if (mult >= 10)
									{
									mult = mult - 8;
									}										
								dv[1] = dv[1] + digitos[i]*mult;
								}	
							}
						//cout << dv[0] << " - " << dv[1] << endl;
						dv[0] =  dv[0] % 11;
						dv[1] =  dv[1] % 11;
						//cout << dv[0] << "=" << digitado[12] << endl;
						//cout << dv[1] << "=" << digitado[13] << endl;
						if (dv[0] == 10)
							{
							dv[0] = 0;
							}
						if (dv[1] == 10)
							{
							dv[1] = 0;
							}
						if ((dv[0] != digitos[12])||(dv[1] != digitos[13]))
							{
							Gtk::MessageDialog dialog(*this->Editar, Glib::ustring("Checagem de CNPJ"), false, Gtk::MESSAGE_ERROR);
							dialog.set_message(Glib::ustring("CNPJ inválido"));
							dialog.run();
							this->Editar->set_focus(*this->E_DocNov);
							}
						}
					this->E_DocNov->set_text(digitado);
					break;
					}
				}
			break;
			}
		}
	}

/**
 * Carrega uma janela dinâmica para efetuar o cadastro de um novo registro, este
 * pode ser de um usuário do sistema, um cliente ou um serviço.
 */
void PRINCIPAL::novo()
	{
	string codigo;
	Gtk::Fixed *N_Tela;
	Gtk::Label *L_Novo;
	Gtk::Label *Aviso;
	Gtk::Button *B_Novo;
	Gtk::RadioButton::Group Imposto, ISSQN;
	Gtk::RadioButton *S_Imp, *S_SubISSQN;
	Gtk::HBox *HBOX;
	Gtk::VBox *VBOX;

	this->acao = 1;
	this->Novo = new Gtk::Window();
	this->Novo->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	this->Novo->set_position(Gtk::WIN_POS_CENTER);
	this->Novo->set_icon(this->ponteiro_icon);
	switch(this->janelas)
		{
		case 5:
			{
			this->n_codigo = this->novo_codigo();
			codigo.clear();
			codigo = "Código: <b>" + this->n_codigo + "</b>";
			this->Novo->set_title(Glib::ustring("Criação de Novo Funcionário"));
			this->Novo->set_size_request(400,200);
			N_Tela = new Gtk::Fixed();
			L_Novo = new Gtk::Label();
			L_Novo->set_markup(codigo);
			N_Tela->put(*L_Novo,10,10);
			L_Novo = new Gtk::Label("Nome: ");
			this->N_ENome = new Gtk::Entry();
			this->N_ENome->set_size_request(310,28);
			N_Tela->put(*L_Novo,10,40);
			N_Tela->put(*this->N_ENome,80,35);
			L_Novo = new Gtk::Label("Login: ");
			this->N_ELogin = new Gtk::Entry();
			this->N_ELogin->set_size_request(120,28);
  			this->N_ELogin->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),1));
			this->N_ELogin->set_max_length(10);
			Aviso = new Gtk::Label();
			Aviso->set_markup(Glib::ustring("<b>Máximo 10 caracteres</b>"));
			N_Tela->put(*L_Novo,10,70);
			N_Tela->put(*this->N_ELogin,80,65);
			N_Tela->put(*Aviso,210,70);
			L_Novo = new Gtk::Label("Senha: ");
			this->N_ESenha = new Gtk::Entry();
			this->N_ESenha->set_size_request(120,28);
			this->N_ESenha->set_max_length(10);
			this->N_ESenha->set_visibility(false);
			this->N_ESenha->set_invisible_char('$');
			Aviso = new Gtk::Label();
			Aviso->set_markup(Glib::ustring("<b>Máximo 10 caracteres</b>"));
			N_Tela->put(*L_Novo,10,100);
			N_Tela->put(*this->N_ESenha,80,95);
			N_Tela->put(*Aviso,210,100);
			B_Novo = new Gtk::Button(Gtk::Stock::SAVE);
			B_Novo->set_size_request(80,28);
			B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
			N_Tela->put(*B_Novo,20,150);
			B_Novo = new Gtk::Button(Gtk::Stock::QUIT);
			B_Novo->set_size_request(80,28);
			B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),6));
			N_Tela->put(*B_Novo,100,150);
			this->Novo->add(*N_Tela);
			break;
			}
		case 6:
			{
			this->n_codigo = this->novo_codigo();
			this->Novo->set_title(Glib::ustring("Cadastro de Clientes::Inclusão"));
			this->Novo->set_size_request(400,235);
			this->Novo->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),6));
			VBOX = new Gtk::VBox(false,0);
			N_Tela = new Gtk::Fixed();
			L_Novo = new Gtk::Label(Glib::ustring("Natureza Jurídica: "));
			this->CBT_Novo = new Gtk::ComboBoxText();
			N_Tela->put(*L_Novo,10,10);
			N_Tela->put(*this->CBT_Novo,130,5);
			/* Dados da Natureza Jurídica */
			this->CBT_Novo->clear();
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			this->CBT_Novo->set_model(arvore_ref);
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_jur] = 0;
			this->celula[arvore_reg.descricao] = "Selecione...";
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_jur] = 1;
			this->celula[arvore_reg.descricao] = Glib::ustring("Física");
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_jur] = 2;
			this->celula[arvore_reg.descricao] = Glib::ustring("Jurídica");
			this->CBT_Novo->set_active(0);
			/*Dados da Natureza Jurídica */
			L_Novo = new Gtk::Label(Glib::ustring("Código:"));
			this->E_CodNov = new Gtk::Entry();
			this->E_CodNov->set_size_request(100,28);
			this->E_CodNov->set_text(this->n_codigo);
			N_Tela->put(*L_Novo,10,40);
			N_Tela->put(*this->E_CodNov,80,35);
			L_Novo = new Gtk::Label(Glib::ustring("Nome: "));
			this->E_NomeNov = new Gtk::Entry();
			this->E_NomeNov->set_size_request(300,28);
			this->E_NomeNov->set_max_length(100);
			this->E_NomeNov->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),8));
			N_Tela->put(*L_Novo,10,70);
			N_Tela->put(*this->E_NomeNov,80,65);
			L_Novo = new Gtk::Label(Glib::ustring("Endereço: "));
			this->E_EndNov = new Gtk::Entry();
			this->E_EndNov->set_size_request(300,28);
			this->E_EndNov->set_max_length(200);
			this->E_EndNov->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),9));
			N_Tela->put(*L_Novo,10,100);
			N_Tela->put(*this->E_EndNov,80,95);
			L_Novo = new Gtk::Label("Documento: ");
			this->E_DocNov = new Gtk::Entry();
			this->E_DocNov->set_size_request(150,28);
			this->E_DocNov->set_max_length(20);
			this->E_DocNov->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checar_documento),1));
			N_Tela->put(*L_Novo,10,130);
			N_Tela->put(*this->E_DocNov,100,125);
			B_Novo = new Gtk::Button(Gtk::Stock::SAVE);
			B_Novo->set_size_request(120,28);
			B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
			N_Tela->put(*B_Novo,20,160);
			B_Novo = new Gtk::Button(Gtk::Stock::CANCEL);
			B_Novo->set_size_request(120,28);
			B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),6));
			N_Tela->put(*B_Novo,150,160);
			S_Imp = new Gtk::RadioButton(Glib::ustring("Não Crédito"));
			Imposto = S_Imp->get_group();
			this->Imp = new Gtk::RadioButton(Imposto,Glib::ustring("Crédito"));
			HBOX = new Gtk::HBox(false,0);
			HBOX->pack_start (*this->Imp,false,false,0);
			HBOX->pack_start (*S_Imp,false,false,0);
			VBOX->pack_start(*HBOX,false,false,0);
			S_SubISSQN = new Gtk::RadioButton(Glib::ustring("Não Sub ISSQN"));
			ISSQN = S_SubISSQN->get_group();
			this->SubISSQN = new Gtk::RadioButton(ISSQN,Glib::ustring("Sub ISSQN"));
			HBOX = new Gtk::HBox(false,0);
			HBOX->pack_start (*this->SubISSQN,false,false,0);
			HBOX->pack_start (*S_SubISSQN,false,false,0);
			VBOX->pack_start(*HBOX,false,false,0);
			VBOX->pack_start(*N_Tela,false,false,0);
			this->Novo->add(*VBOX);
			break;
			}
		case 7:
			{
			this->Novo->set_title(Glib::ustring("Cadastro de Serviços::Inclusão"));
			this->Novo->set_size_request(400,180);
			this->Novo->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),6));
			VBOX = new Gtk::VBox(false,0);
			N_Tela = new Gtk::Fixed();
			L_Novo = new Gtk::Label(Glib::ustring("Tipo Serviço:"));
			this->CBT_Novo = new Gtk::ComboBoxText();
			N_Tela->put(*L_Novo,10,10);
			N_Tela->put(*this->CBT_Novo,110,5);
			/* Dados do Tipo de Serviço */
			this->CBT_Novo->clear();
			this->arvore_ref = Gtk::ListStore::create(this->arvore_reg);
			this->CBT_Novo->set_model(this->arvore_ref);
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_serv] = 0;
			this->celula[arvore_reg.descricao] = "Selecione...";
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_serv] = 1;
			this->celula[arvore_reg.descricao] = "Entrada";
			this->celula = *(arvore_ref->append());
			this->celula[arvore_reg.tipo_serv] = 2;
			this->celula[arvore_reg.descricao] = Glib::ustring("Saída");
			this->CBT_Novo->set_active(0);
			/*Dados do Tipo de Serviço */
			this->CBT_Novo->signal_changed().connect(sigc::mem_fun(*this,&PRINCIPAL::sel_tipo));
			this->L_CodNov = new Gtk::Label(Glib::ustring("Código: "));
			N_Tela->put(*this->L_CodNov,10,40);
			L_Novo = new Gtk::Label(Glib::ustring("Descrição: "));
			N_Tela->put(*L_Novo,10,70);
			this->E_DescNov = new Gtk::Entry();
			this->E_DescNov->set_size_request(290,28);
			this->E_DescNov->set_max_length(100);
			this->E_DescNov->set_sensitive(false);
			this->E_DescNov->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_nome),5));
			this->E_DescNov->signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular),4));
			N_Tela->put(*this->E_DescNov,100,65);
			L_Novo = new Gtk::Label(Glib::ustring("Valor R$: "));
			N_Tela->put(*L_Novo,10,100);
			this->E_ValNov = new Gtk::Entry();
			this->E_ValNov->set_size_request(180,28);
			this->E_ValNov->set_sensitive(false);
			this->E_ValNov->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),this->E_ValNov,1));
			N_Tela->put(*this->E_ValNov,100,95);
			S_Imp = new Gtk::RadioButton(Glib::ustring("Sem Imposto"));
			Imposto = S_Imp->get_group();
			this->Imp = new Gtk::RadioButton(Imposto,Glib::ustring("Imposto"));
			B_Novo = new Gtk::Button(Gtk::Stock::OK);
			HBOX = new Gtk::HBox(false,0);
			HBOX->pack_start (*this->Imp,false,false,0);
			HBOX->pack_start (*S_Imp,false,false,0);
			VBOX->pack_start(*HBOX,false,false,0);
			B_Novo->set_size_request(120,28);
			B_Novo->signal_clicked().connect(sigc::mem_fun(*this,&PRINCIPAL::gravar_dados));
			N_Tela->put(*B_Novo,20,125);
			B_Novo = new Gtk::Button(Gtk::Stock::CANCEL);
			B_Novo->set_size_request(120,28);
			B_Novo->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),6));
			N_Tela->put(*B_Novo,150,125);
			VBOX->pack_start(*N_Tela,false,false,0);
			this->Novo->add(*VBOX);
			break;
			}
		}
	this->Novo->show_all();
	Gtk::Main::run(*this->Novo);
	}

/**
 * Ao selecionar o tipo de serviço a ser cadastrado ele libera o formulário de PRINCIPAL::Novo
 * para cadastramento gerando o novo código do serviço a ser cadastrado.
 */
void PRINCIPAL::sel_tipo()
	{
	string codigo;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	switch(this->janelas)
		{
		case 7:
			{
			contador = this->CBT_Novo->get_active();
			if(contador)
				{
				registro=*contador;
				if(registro)
					{
					this->e_s = registro[arvore_reg.tipo_serv];
					}
				}
			this->n_codigo = this->novo_codigo();
			codigo.clear();
			codigo = "Código: <b>" + this->n_codigo + "</b>";
			this->L_CodNov->set_markup(Glib::ustring(codigo));
			this->E_DescNov->set_sensitive(true);
			this->E_ValNov->set_sensitive(true);
			break;
			}
		}
	}

/**
 * Neste metódo é tratado as inclusões, alterações e exclusões de informações do sistema.\n
 * A ação que será executada é controlada pela PRINCIPAL::acao que pode assumir os valores:\n
 * 1 - Inclusão\n 2 - Alteração\n 3 - Exclusão
 */
void PRINCIPAL::gravar_dados()
	{
	char *sql, *aux;
	string SQL, AUX;
	int it;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
		
	switch(this->acao)
		{
		case 1:
			{
			switch(this->janelas)
				{
				case 5:
					{
					SQL.clear();
					SQL = "insert into cadastro.funcionario values(" + this->n_codigo + ",'";
					SQL += this->N_ENome->get_text() + "','" + this->N_ELogin->get_text() + "',";
					SQL += "md5('" + this->N_ESenha->get_text() + "'),9);";
					//cout << SQL << endl;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 1)
						{
						this->carregar_dados();
						this->sair(6);
						}
					else if (this->conexao->query_result == 3)
						{								
						cout << SQL << endl;
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					break;
					}
				case 6:
					{
					SQL.clear();
					SQL = "insert into cadastro.clientes values("+this->n_codigo + ",'";
					AUX.clear();
					AUX = this->E_NomeNov->get_text();
					SQL += AUX + "','";
					AUX.clear();
					AUX = this->E_EndNov->get_text();
					SQL += AUX + "','";
					AUX.clear();
					AUX = this->E_DocNov->get_text();
					SQL += AUX + "',";
					contador = this->CBT_Novo->get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							aux = new char[10];
							itoa(registro[arvore_reg.tipo_jur],aux,10);
							SQL.append(aux);
							delete aux;
							}
						}
					SQL += AUX + ",";
					if (this->Imp->get_active ())
						{
						SQL += "true,";
						}
					else
						{
						SQL += "false,";
						}
					if (this->SubISSQN->get_active ())
						{
						SQL += "true";
						}
					else
						{
						SQL += "false";
						}
					SQL += ")";
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 1)
						{
						this->carregar_dados();
						this->sair(6);
						}
					else if (this->conexao->query_result == 3)
						{								
						cout << SQL << endl;
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					break;
					}
				case 7:
					{
					SQL.clear();
					SQL = "insert into cadastro.servicos (e_s,codigo,descricao,valor_u,f10) values (";
					contador = this->CBT_Novo->get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							aux = new char[10];
							itoa(registro[arvore_reg.tipo_serv],aux,10);
							SQL.append(aux);
							delete aux;
							}
						}
					SQL += "," + this->n_codigo + ",'";
					SQL.append(this->E_DescNov->get_text());
					SQL += "','";
					AUX = this->E_ValNov->get_text();
					it = AUX.find(",");
					if (it!=string::npos)
	  					{
						AUX.replace(it,1,".");
						}
					SQL += AUX + "',";
					if (this->Imp->get_active ())
						{
						SQL += "true";
						}
					else
						{
						SQL += "false";
						}
					SQL += ")";
					cout << SQL << endl;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 1)
						{
						this->carregar_dados();
						this->sair(6);
						}
					else if (this->conexao->query_result == 3)
						{								
						cout << SQL << endl;
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					break;
					}
				}
			break;
			}
		case 2:
			{
			switch(this->janelas)
				{
				case 5:
					{
					SQL.clear();
					SQL = "update cadastro.funcionario set nome='" + this->N_ENome->get_text() + "',";
					SQL += "u_login='" + this->N_ELogin->get_text() + "',acesso=";
					contador = this->N_CNivel->get_active();
					if(contador)
						{
						registro=*contador;
						if(registro)
							{
							aux = new char[10];
							itoa(registro[arvore_reg.cod_acesso],aux,10);
							SQL.append(aux);
							delete aux;
							}
						}
					SQL += " where cod_fun=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					//cout << SQL << endl;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 3)
						{
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					this->Editar->hide();
					break;
					}
				case 6:
					{
					SQL.clear();
					SQL = "update cadastro.clientes set nome='" + this->E_NomeNov->get_text() + "', ";
					SQL += "endereco='" + this->E_EndNov->get_text() + "', documento='" + this->E_DocNov->get_text() +"',credito=";
					if (this->Imp->get_active ())
						{
						SQL += "true, sub_issqn=";
						}
					else
						{
						SQL += "false, sub_issqn=";
						}
					if (this->SubISSQN->get_active ())
						{
						SQL += "true";
						}
					else
						{
						SQL += "false";
						}
					SQL += " where cod_cli=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					//cout << SQL << endl;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 3)
						{
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					this->Editar->hide();
					break;
					}
				case 7:
					{
					SQL.clear();
					SQL = "update cadastro.servicos set descricao='";//,valor_u) values (";
					SQL.append(this->E_DescNov->get_text());
					SQL += "',valor_u='";
					AUX = this->E_ValNov->get_text();
					it = AUX.find(",");
					if (it!=string::npos)
	  					{
						AUX.replace(it,1,".");
						}
					SQL += AUX + "',f10=";
					if (this->Imp->get_active ())
						{
						SQL += "true";
						}
					else
						{
						SQL += "false";
						}
					SQL += " where cod_serv=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					//cout << SQL << endl;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 1)
						{
						this->carregar_dados();
						this->sair(7);
						}
					else if (this->conexao->query_result == 3)
						{								
						cout << SQL << endl;
						cout << this->conexao->mensagem << endl;
						}
					delete sql;
					break;
					}
				}
			break;
			}
	  case 3:
			{
			switch(this->janelas)
				{
				case 5:
					{
					SQL.clear();
					SQL = "delete from cadastro.funcionario where cod_fun=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 3)
						{
						Gtk::MessageDialog dialog(this->Contas, Glib::ustring("Deletar Funcionário"), false, Gtk::MESSAGE_ERROR);
						dialog.set_message(Glib::ustring("Erro ao deletar funcionário: "));
						dialog.set_secondary_text(Glib::ustring(this->conexao->mensagem));
						dialog.run();
						}
					this->carregar_dados();
					break;
					}
				case 6:
					{
					SQL.clear();
					SQL = "delete from cadastro.clientes where cod_cli=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 3)
						{
						Gtk::MessageDialog dialog(this->Servico, Glib::ustring("Deletar Cliente"), false, Gtk::MESSAGE_ERROR);
						dialog.set_message(Glib::ustring("Erro ao deletar cliente: "));
						dialog.set_secondary_text(Glib::ustring(this->conexao->mensagem));
						dialog.run();
						}
					this->carregar_dados();
					break;
					}
				case 7:
					{
					SQL.clear();
					SQL = "delete from cadastro.servicos where cod_serv=";
					aux = new char[10];
					itoa(this->cod_sel,aux,10);
					SQL.append(aux);
					delete aux;
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					if (this->conexao->query_result == 3)
						{
						Gtk::MessageDialog dialog(this->Servico, Glib::ustring("Deletar Serviço"), false, Gtk::MESSAGE_ERROR);
						dialog.set_message(Glib::ustring("Erro ao deletar serviço: "));
						dialog.set_secondary_text(Glib::ustring(this->conexao->mensagem));
						dialog.run();
						}
					this->carregar_dados();
					}
				break;
				}
			break;
			}
		}
	}

/**
 * Este método modifica o PRINCIPAL::acao para o valor 3 e aciona o método
 * PRINCIPAL::gravar_dados para executar a ação de exclusão conforme o PRINCIPAL::janelas 
 * ativo.
 */
void PRINCIPAL::deletar()
	{
	this->acao = 3;
	this->gravar_dados();
	}

/**
 * Utilizado para ler um arquivo do tipo CVS e gravar suas informações na base de dados.
 * \param sel informa para o método qual tipo de informação será importada.\n
 * 1 - Cadastro de Funcionários.\n
 * 2 - Cadastro de Serviços de Entrada.\n
 * 3 - Cadastro de Serviços de Saída.\n
 * 4 - Cadastro de Clientes.\n
 * 5 - Lançamentos de Entradas.\n
 * 6 - Lançamentos de Entradas detalhadas.\n
 */
void PRINCIPAL::importar(int sel)
	{
	int resultado,i,j,line,doc,ix,qtd;
	float valor, valor_u, desconto, valor_liq;
	string arquivo, texto, aux, aux2, data, mes_f[12], cliente[5], txt, servico[2], dados[20], recibo;
	char *aux_dt, *sql, *aux_t;
 	size_t it;
	ifstream farquivo;
	ofstream log;
	bool mudou;

	mudou = false;
	//cout << this->importa << endl;
	Gtk::FileSelection dialog("Selecione um Arquivo a ser importado:");
  	dialog.set_transient_for(this->Principal);

	{
	//Inicializando meses
	mes_f[0].clear();
	mes_f[0].append("janeiro");
	mes_f[1].clear();
	mes_f[1].append("fevereiro");
	mes_f[2].clear();
	mes_f[2].append("março");
	mes_f[3].clear();
	mes_f[3].append("abril");
	mes_f[4].clear();
	mes_f[4].append("maio");
	mes_f[5].clear();
	mes_f[5].append("junho");
	mes_f[6].clear();
	mes_f[6].append("julho");
	mes_f[7].clear();
	mes_f[7].append("agosto");
	mes_f[8].clear();
	mes_f[8].append("setembro");
	mes_f[9].clear();
	mes_f[9].append("outubro");
	mes_f[10].clear();
	mes_f[10].append("novembro");
	mes_f[11].clear();
	mes_f[11].append("dezembro");
	}
	aux_dt = new char[10];
  
  	resultado = dialog.run();
  	switch(resultado)
  		{
  		case(Gtk::RESPONSE_OK):
    		{
     		arquivo = dialog.get_filename();
			cout << "Arquivo selecionado: " <<  arquivo << endl;
			farquivo.open(arquivo.c_str());
			log.open("docs/import.sql");
			switch(sel)
				{
				case 1:
					{
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								aux.clear();
								aux = "insert into cadastro.funcionario (senha,u_login,nome,cod_fun,acesso) values ";
								aux += "(md5('";
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								aux += texto + "'),'";
								break;
								}
						  	case 1:
						    	{
								it = texto.find('"');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								it = texto.find('"');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								aux += texto + "','" + texto + "',";
								break;
								}
							case 2:
								{
								aux += texto + ",9);";
								sql = new char[aux.length()+1];
							  	strcpy(sql,aux.c_str());
								log << "Linha " << line << ": " << sql << endl;
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							  	delete sql;
						    	break;
								}
							}
					  	if(i == 2)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					break;
					}
			  case 2:
					{
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								aux.clear();
								aux = "insert into cadastro.servicos (e_s,codigo,descricao,valor_u) values (1,";
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								aux += texto + ",'";
								break;
								}
							case 1:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								aux += texto + "','";
								break;
								}
							case 2:
								{
								if(texto.length() == 0)
									{
									aux += "0.0');";
									}
							  	else
									{
									it = texto.find(',');
									if (it!=string::npos)
						  				{
										texto.replace(it,1,".");
										}
									aux += texto + "');";
									}
								sql = new char[aux.length()+1];
							  	strcpy(sql,aux.c_str());
								log << "Linha " << line << ": " << sql << endl;
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							 	delete sql;
						   		break;
								}
							}
						if(i == 2)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					
					break;
					}
				case 3:
					{
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								aux.clear();
								aux = "insert into cadastro.servicos (e_s,codigo,descricao,valor_u) values (2,";
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								aux += texto + ",'";
								break;
								}
							case 1:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								aux += texto + "','";
								break;
								}
							case 2:
								{
								if(texto.length() == 0)
									{
									aux += "0.0');";
									}
							  	else
									{
									it = texto.find(',');
									if (it!=string::npos)
						  				{
										texto.replace(it,1,".");
										}
									aux += texto + "');";
									}
								sql = new char[aux.length()+1];
							  	strcpy(sql,aux.c_str());
								log << "Linha " << line << ": " << sql << endl;
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							  	delete sql;
						    	break;
								}
							}
						if(i == 2)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}										
					break;
					}
				case 4:
					{
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								aux.clear();
								aux = "insert into cadastro.clientes values (";
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								aux += texto + ",'";
								break;
								}
							case 1:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								aux += texto + "','";
								break;
								}
							case 2:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								aux += texto + "','";
								break;
								}
							case 3:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								doc = 0;
								if (texto.length() > 0)
									{
									aux_t = new char[texto.length()+1];
									strcpy(aux_t,texto.c_str());
									if (texto.length() < 18)
										{
										doc = 1;
										aux_t = masc_doc(aux_t,1,1);
										}
									else
										{
										doc = 2;
										aux_t = masc_doc(aux_t,2,1);
										}
									}
								else
									{
									aux_t = new char[1];
									aux_t[0] = '\0';
									}
								aux.append(aux_t);
								delete aux_t;
								aux += "',";
								aux_t = new char[5];
								itoa(doc,aux_t,10);
								aux.append(aux_t);
								delete aux_t;
								aux += ",true,false);";
								sql = new char[aux.length()+1];
							  	strcpy(sql,aux.c_str());
								log << "Linha " << line << ": " << sql << endl;
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							  	delete sql;
						    	break;
								}
							}
						if(i == 3)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					
					break;
					}
				case 5:
					{
					//Lançamento do Caixa
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								//E_S e Data
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								dados[i].clear();
								dados[i] = texto;
								break;
								}
							case 1:
								{
								//DATA
								dados[i].clear();
								aux_dt = new char[15];
								strcpy(aux_dt,texto.c_str());
								dados[i].append(data_formatada(aux_dt,1));
								delete aux_dt;
								break;
								}
							case 2:
								{
								//código cliente
								cliente[0] = texto;
								//cout << texto << endl;
								break;
								}
							case 3:
								{
								//Nome Cliente
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								cliente[1] = texto;
								//cout << texto << endl;
								break;
								}
							case 4:
								{
								//Endereço Cliente
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								cliente[2] = texto;
								//cout << texto << endl;
								break;
								}
							case 5:
								{
								//Documento Cliente
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								txt.clear();
								int ot = 0;
								for (int cp=0; cp < texto.length() ; cp++)
									{
									if (isdigit(texto[cp]))
										{
										txt[ot] = texto[cp];
										ot++;
										}
									}
								cliente[3] = txt;
								//Checando a existência do Cliente
								dados[2].clear();
								dados[2] = this->verificar_cliente (cliente);
								break;
								}
							case 6:
								{
								//Código Funcionario
								dados[3].clear();
								dados[3] = texto;
								//cout << texto << endl;
								break;
								}
							case 7:
								{
								//Nome Funcionário
								//cout << texto << endl;
								break;
								}
							case 8:
								{
								//Valor Desconto
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								dados[4].clear();
								dados[4] = texto;
								//cout << texto << endl;
								break;
								}
							case 9:
								{
								//Valor Total
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								dados[5].clear();
								dados[5] = texto;
								//cout << texto << endl;
								break;
								}
							case 10:
								{
								//Valor Total Liquido
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								dados[6].clear();
								dados[6] = texto;
								//cout << texto << endl;
								break;
								}
							case 11:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								dados[7].clear();
								if (texto.compare("OK") == 0)
									{
									dados[7] =  "true";
									}
							  	else
									{
									dados[7] = "false";
									}
								//cout << texto << endl;
								break;
								}
							case 12:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								dados[8].clear();
								dados[8] = texto;
								//cout << texto << endl;
								break;
								}
							case 14:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								dados[9].clear();
								dados[9] = texto;
								//cout << texto << endl;
								break;
								}
							case 15:
								{
								dados[10].clear();
								aux_dt = new char[15];
								strcpy(aux_dt,texto.c_str());
								dados[10].append(data_formatada(aux_dt,1));
								delete aux_dt;
								//cout << texto << endl;
								break;
								}
							case 16:
								{
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								if (texto.length() == 0)
									{
									texto = "0.0";
									}
								dados[11].clear();
								dados[11] = texto;
								//cout << texto << endl;
								break;
								}
							case 17:
								{
								dados[12].clear();
								if (texto.length() > 0)
									{
									dados[12] = "'";
									aux_dt = new char[15];
									strcpy(aux_dt,texto.c_str());
									dados[12].append(data_formatada(aux_dt,1));
									delete aux_dt;
									dados[12] += "'";
									}
								else
									{
									dados[12] = "null";
									}
								//cout << texto << endl;
								break;
								}
							case 18:
								{
								dados[13].clear();
								if (texto.length() == 0)
									{
									dados[13] = "0";
									}
								else
									{
									dados[13] = texto;
									}
								aux.clear();
								aux = "insert into caixa.lancamentos values (1,"+dados[0]+",'"+dados[1]+"',"+dados[2]+","+dados[3]+",'"+dados[4]+"','"+dados[5]+"','"+dados[6]+"',"+dados[7]+",'"+dados[8]+"',1,'"+dados[9]+"','"+dados[10]+"','"+dados[11]+"',"+dados[12]+","+dados[13]+")";
								log << "Linha " << line << ": " << aux << endl;
								sql = new char[aux.length()+1];
								strcpy(sql,aux.c_str());
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							  	delete sql;
						    	break;
								}
							}
						if(i == 18)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					
					break;
					}
				case 6:
					{
					//Lançamento do Caixa Entradas Detalhamento
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								//E_S e REC
								it = texto.find('\n');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									}
								dados[0].clear();
								dados[0] = texto;
								if (dados[0].length() > 0)
									{
									mudou = true;
									}
								else
									{
									mudou = false;
									}
								if (mudou)
									{
									recibo.clear();
									recibo = dados[0];
									}
								break;
								}
							case 1:
								{
								//DATA
								dados[1].clear();
								aux_dt = new char[15];
								strcpy(aux_dt,texto.c_str());
								dados[1].append(data_formatada(aux_dt,1));
								delete aux_dt;
								}
							case 2:
								{
								servico[0] = texto;
								break;
								}
							case 3:
								{
								it = texto.find('"');
								while (it!=string::npos)
						  			{
									texto.replace(it,1,"");
									it = texto.find('"');
									}
								servico[1] = texto;
								dados[2].clear();
								dados[2] = this->verificar_servico(servico);
								break;
								}
							case 4:
								{
								dados[3].clear();
								dados[3] = texto;
								break;
								}
							case 5:
							case 6:
							case 7:
								{
								if (texto.length() == 0)
									{
									texto = "0,0";
									}
								dados[i-1].clear();
								dados[i-1] = texto;
								break;
								}
							case 8:
								{
								if (texto.length() == 0)
									{
									texto = "0,0";
									}
								dados[7].clear();
								dados[7] = texto;
								aux.clear();
								aux = "insert into caixa.entrada values(1,"+dados[0]+",'"+dados[1]+"',"+dados[2]+","+dados[3]+",'";
								qtd = atoi(dados[3].c_str());
								it = dados[4].find(".");
								if (it != string::npos)
									{
									dados[4].replace(it,1,",");
									}
								valor = atof(dados[4].c_str());
								valor_u = valor/qtd;
								it = dados[5].find(".");
								if (it != string::npos)
									{
									dados[5].replace(it,1,",");
									}
								desconto = atof(dados[5].c_str());
								valor_liq = valor - desconto;
								aux_dt = new char[32];
								sprintf(aux_dt,"%.02f",valor_u);
								dados[4].clear();
								dados[4].append(aux_dt);
								delete aux_dt;
								it = dados[4].find(',');
								if (it != string::npos)
									{
									dados[4].replace(it,1,".");
									}
								aux += dados[4] + "','";
								it = dados[5].find(',');
								if (it != string::npos)
									{
									dados[5].replace(it,1,".");
									}
								aux += dados[5] + "','";
								aux_dt = new char[32];
								sprintf(aux_dt,"%.02f",valor);
								dados[6].clear();
								dados[6].append(aux_dt);
								delete aux_dt;
								it = dados[6].find(',');
								if (it != string::npos)
									{
									dados[6].replace(it,1,".");
									}
								aux += dados[6] + "','";
								aux_dt = new char[32];
								sprintf(aux_dt,"%.02f",valor_liq);
								dados[7].clear();
								dados[7].append(aux_dt);
								delete aux_dt;
								it = dados[7].find(',');
								if (it != string::npos)
									{
									dados[7].replace(it,1,".");
									}
								aux += dados[7] + "')";
								log << "Linha " << line << ": " << aux << endl;
								sql = new char[aux.length()+1];
								strcpy(sql,aux.c_str());
								this->conexao->executar(sql);
								log << this->conexao->mensagem << endl;
								line++;
							  	delete sql;
						    	break;
								}
							}
						if(i == 8)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					aux.clear();
					aux = "SELECT setval('caixa.cadastro_cod_cli_seq', "+recibo+", true)";
					log << "Contadores : " << aux << endl;
					sql = new char[aux.length()+1];
					strcpy(sql,aux.c_str ());
					this->conexao->executar(sql);
					log << this->conexao->mensagem << endl;
					delete sql;
					break;
					}
				case 7:
					{
					//Lancamentos de Saidas;
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								it = texto.find('\n');
								if (it!=string::npos)
									{
									texto.replace(it,1,"");
									}
								//DATA
								dados[0].clear();
								aux_dt = new char[15];
								strcpy(aux_dt,texto.c_str());
								if (strlen(aux_dt) > 0)
									{
									dados[0].append(data_formatada(aux_dt,1));
									delete aux_dt;
									mudou = true;
									}
								else
									{
									mudou = false;
									}
								break;
								}
							case 1:
								{
								dados[1].clear();
								dados[1] = this->servico_saida(texto);
								break;
								}
							case 2:
							case 4:
							case 5:
								{
								dados[i].clear();
								dados[i] = texto;
								if (mudou)
									{
									recibo.clear();
									recibo = dados[5];
									}
								if (i == 5)
									{
									aux.clear();
									aux = "insert into caixa.lancamentos (e_s,data,rec,cod_cli,cod_fun,total,total_liq) values (2,'"+dados[0]+"',"+dados[5]+",8,"+dados[4]+",'"+dados[3]+"','"+dados[3]+"');";
									aux += "insert into caixa.saida values(2,"+dados[5]+",'"+dados[0]+"',"+dados[1]+",'"+dados[3]+"','"+dados[2]+"');";
									log << "Linha " << line << ": " << aux << endl;
									sql = new char[aux.length()+1];
									strcpy(sql,aux.c_str ());
									this->conexao->executar(sql);
									delete sql;
									log << this->conexao->mensagem << endl;
									line++;
									}
								//cout << line << " : 3660" << endl;
								break;
								}
							case 3:
								{
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								if (texto.length() == 0)
									{
									texto = "0.0";
									}
								dados[3].clear();
								dados[3] = texto;
								break;
								}
							}
						if(i == 5)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					aux.clear();
					aux = "SELECT setval('caixa.saida_inc', "+recibo+", true)";
					log << "Contadores : " << aux << endl;
					sql = new char[aux.length()+1];
					strcpy(sql,aux.c_str ());
					this->conexao->executar(sql);
					log << this->conexao->mensagem << endl;
					delete sql;
					break;
					}
				case 8:
					{
					i = 0;
					line = 1;
					while (farquivo.good())
						{
						getline(farquivo,texto,';');
						switch(i)
							{
							case 0:
								{
								it = texto.find('\n');
								if (it!=string::npos)
									{
									texto.replace(it,1,"");
									}
								//DATA
								dados[0].clear();
								aux_dt = new char[15];
								strcpy(aux_dt,texto.c_str());
								dados[0].append(data_formatada(aux_dt,1));
								delete aux_dt;
								break;
								}
							default:
								{
								it = texto.find(',');
								if (it!=string::npos)
						  			{
									texto.replace(it,1,".");
									}
								if (texto.length() == 0)
									{
									texto = "0.0";
									}
								dados[i].clear();
								dados[i] = texto;
								if (i == 8)
									{
									aux.clear();
									aux = "insert into caixa.saldo values('"+dados[0]+"','"+dados[1]+"','"+dados[4]+"','"+dados[2]+"','"+dados[8]+"','"+dados[6]+"','"+dados[5]+"','"+dados[3]+"','"+dados[7]+"')" ;
									log << "Linha " << line << ": " << aux << endl;
									sql = new char[aux.length()+1];
									strcpy(sql,aux.c_str ());
									this->conexao->executar(sql);
									log << this->conexao->mensagem << endl;
									line++;
									}
								break;
								}
							}
						if(i == 8)
							{
							i = 0;
							}
			  			else
							{
							i++;
							}
						}
					break;
					}
				}
		  	farquivo.close();
		  	log.close();
      		break;
    		}
		case(Gtk::RESPONSE_CANCEL):
			{
		 	break;
			}
		default:
			{
		  	cout << "Unexpected button clicked." <<endl;
		  	break;
	   	 	}
	  	}
	}

/**
 * Aciona a janela de informações do desenvolvimento.
 */
void PRINCIPAL::info()
	{
	About.show_all();
	Gtk::Main::run(About);
	}

/**
 * Nesse método checa-se a conexão com o banco de dados.\n
 * Gerando uma Gtk::MessageDialog de informação ou erro.
 */
void PRINCIPAL::testar_conexao()
	{
	if(this->conexao->conectado)
		{
		Gtk::MessageDialog dialog(this->Principal, "Banco conectado com sucesso", false, Gtk::MESSAGE_INFO);
		dialog.run();
		}
	else
		{
		Gtk::MessageDialog dialog(this->Principal, Glib::ustring("Falha na conexão"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring(conexao->mensagem));
		dialog.run();
		}
	}

/**
 * Esse método carrega as informações da conexão principal com o banco de dados,
 * em uma tela para edição.
 * \param inicializar flag de controle para indicar a primeira execução.
 */
void PRINCIPAL::editar_conexao(bool inicializar)
	{	
	char sgbd[16];

	if (inicializar) 
		{		
		this->editar.set_title("Cadastro de Agenda");
		this->editar.resize(300,200);		
		this->editar.add(Box_Conexao);
		this->Box_Conexao.pack_start(this->tabela_fixa);
		this->Box_Conexao.pack_start(this->caixa_botao, Gtk::PACK_SHRINK);
		
		//LABEL DOS CAMPOS
		this->labHost.set_label("Host");
		this->labBanco.set_label("Banco");
		this->labUser.set_label(Glib::ustring("Usuário"));
		this->labSenha.set_label("Senha");
		this->labSGBD.set_label("SGBD");
		
		//COLOCANDO VALORES NO ENTRY
		this->entHost.set_text(this->conexao->host);
		this->entBanco.set_text(this->conexao->banco);
		this->entUser.set_text(this->conexao->user);
		this->entSenha.set_text(this->conexao->senha);
		this->entSenha.set_visibility(false);
		this->entSenha.set_invisible_char('*');
	  	sprintf(sgbd, "%d", this->conexao->tipo);
		entSGBD.set_text(sgbd);
		
		//BOTAO ALTERAR		
		this->caixa_botao.pack_start(this->botao_alterar, Gtk::PACK_SHRINK);
		this->caixa_botao.set_border_width(5);
		this->caixa_botao.set_layout(Gtk::BUTTONBOX_END);
		this->botao_alterar.set_label("Alterar");
		this->botao_alterar.signal_clicked().connect(sigc::mem_fun(*this, &PRINCIPAL::alterar_conexao));	
		
		//COLOCA OS LABELS NA TABELA
		this->tabela_fixa.put(this->labHost,10,10);
		this->tabela_fixa.put(this->labBanco,10,40);
		this->tabela_fixa.put(this->labUser,10,70);
		this->tabela_fixa.put(this->labSenha,10,100);
		this->tabela_fixa.put(this->labSGBD,10,130);
		
		//COLOCA OS ENTRYS NA TABELA
		this->tabela_fixa.put(this->entHost,120,10);
		this->tabela_fixa.put(this->entBanco,120,40);
		this->tabela_fixa.put(this->entUser,120,70);
		this->tabela_fixa.put(this->entSenha,120,100);
		this->tabela_fixa.put(this->entSGBD,120,130);
		}
	else
		{	
		this->editar.show_all();	
		Gtk::Main::run(this->editar);
		}		
	}

/**
 * As informações da conexão principal com o banco de dados são
 * salvas por esse método no arquivo devido.
 */
void PRINCIPAL::alterar_conexao()
  	{
	this->conf_escreve.open(this->conexao->conf_file.c_str());
	
	this->conexao->host = this->entHost.get_text();
	this->conexao->banco = this->entBanco.get_text();
	this->conexao->user = this->entUser.get_text();
	this->conexao->senha = this->entSenha.get_text();
	this->conexao->tipo = atoi(this->entSGBD.get_text().c_str());
	
	this->conf_escreve << "host=" 	<< this->conexao->host	<< endl;
	this->conf_escreve << "banco=" 	<< this->conexao->banco	<< endl;
	this->conf_escreve << "usuario="	<< this->conexao->user 	<< endl;
	this->conf_escreve << "senha=" 	<< this->conexao->senha	<< endl;
	this->conf_escreve << "sgbd=" 	<< this->conexao->tipo	<< endl;
	this->conf_escreve.close();	
	
	this->conexao->conectar();
	
	this->editar.hide();
	}

/**
 * Este método é executado a cada segundo para atualizar a hora do relógio na
 * PRINCIPAL::BarraStatus1.
 */
bool PRINCIPAL::run()
	{
	string status;
	status.clear();
	status = "Sombra® Designer Visual - ";
	status.append(data_formatada(hoje(),2));
	status += " - ";
	status.append(agora());
	status += " - Usuário: "+this->nome;
	this->statusbar1 = this->BarraStatus1.push(Glib::ustring(status));
	return true;
	/*
	#if  !defined(__WIN32__) && !defined(__WIN__)
	statusbar = this->statusbar1;
	BarraStatus = &this->BarraStatus1;
	pthread_create(&this->tid, &this->attr,relogio,NULL);
	#endif*/
	}

/**
 * Este método instância um objeto da classe RECIBO.
 */
void PRINCIPAL::recibo()
	{
	int codigo;
	codigo = atoi(this->cod_func.c_str());
	Recibo = new RECIBO(this->conexao, codigo,this->caixa);
	}

/**
 * Este método é utilizado na importação dos dados dos clientes.
 * \param dados é passado todos os dados constantes no sistema sobre um determinado 
 * cliente, esse é consultado e se existir retorna o código, caso não exista retorna
 * um novo código criado no banco.
 */
string PRINCIPAL::verificar_cliente(string dados[])
	{
	char *sql;
	int it;
	string SQL, retorno;
	BANCOPG *teste;
	vector<string> linha;

	teste = new BANCOPG(CONF_FILE);

	retorno.clear();
	retorno.append(dados[0]);
	if ((retorno.compare("") == 0) || (retorno.compare("0") == 0))
		{
		it = dados[1].find("'");
		if (it!=string::npos)
		  {
			dados[1].replace(it,1,"''");
			}
		SQL.clear();
		SQL = "select cod_cli from cadastro.clientes where nome = '" + dados[1] + "'";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		//cout << sql << endl;
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		else
			{
			if (this->conexao->registros != 0)
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				retorno.clear();
				retorno = linha.at(0);
				}
			else
				{
				SQL.clear();
				SQL = "insert into cadastro.clientes values(nextval('cadastro.clientes_nov_inc'),'";
				SQL.append(dados[1]);
				SQL += "','";
				SQL.append(dados[2]);
				SQL += "','";
				SQL.append(dados[3]);
				SQL += "',";
				if (dados[3].length() > 11)
				  {
					SQL += "2) ";
					}
				else
					{
					SQL += "1) ";
					}
				SQL += "returning cod_cli";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				//cout << sql << endl;
				teste->executar(sql);
				delete sql;
				if (teste->query_result == 3)
					{
					cout << teste->mensagem << endl;
					}
				else
					{
					teste->resultado();
					linha = teste->resultados.at(0);
					retorno.clear();
					retorno = linha.at(0);
					}
				}
			}
		}
	delete teste;
	return retorno;
	}

/**
 * Este método é utilizado na importação dos dados dos serviços.
 * \param dados é passado todos os dados constantes no sistema sobre um determinado 
 * serviço, esse é consultado e se existir retorna o código, caso não exista retorna
 * um novo código criado no banco.
 */
string PRINCIPAL::verificar_servico(string dados[])
	{
	char *sql;
	int it;
	string SQL, retorno;
	BANCOPG *teste;
	vector<string> linha;
			
	teste = new BANCOPG(CONF_FILE);
	retorno.clear();
	if ((dados[0].compare("") == 0) || (dados[0].compare("0") == 0))
		{
		SQL.clear();
		SQL = "select cod_serv from cadastro.servicos where e_s=1 and descricao='";
		SQL.append(dados[1]);
		SQL += "';";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		delete sql;
		if ((this->conexao->query_result == 3)||(this->conexao->registros == 0))
			{
			cout << this->conexao->mensagem << endl;
			SQL.clear();
			SQL = "insert into cadastro.servicos (cod_serv,e_s,codigo,descricao) values(nextval('cadastro.servicos_cod_serv_seq'),1,";
			SQL.append(dados[0]);
			SQL += ",'";
			SQL.append(dados[1]);
			SQL += "') returning cod_serv;";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			teste->executar(sql);
			delete sql;
			if (teste->query_result == 3)
				{
				cout << teste->mensagem << endl;
				}
			else
				{
				teste->resultado();
				linha = teste->resultados.at(0);
				retorno = linha.at(0);
				}
			}
		else
			{
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			retorno = linha.at(0);
			}
		}
	else
		{
		SQL.clear();
		SQL = "select cod_serv from cadastro.servicos where e_s=1 and codigo=";
		SQL.append(dados[0]);
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		delete sql;
		if ((this->conexao->query_result == 3)||(this->conexao->registros == 0))
			{
			cout << this->conexao->mensagem << endl;
			SQL.clear();
			SQL = "insert into cadastro.servicos (cod_serv,e_s,codigo,descricao) values(nextval('cadastro.servicos_cod_serv_seq'),1,";
			SQL.append(dados[0]);
			SQL += ",'";
			SQL.append(dados[1]);
			SQL += "') returning cod_serv;";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			teste->executar(sql);
			delete sql;
			if (teste->query_result == 3)
				{
				cout << teste->mensagem << endl;
				}
			else
				{
				teste->resultado();
				linha = teste->resultados.at(0);
				retorno = linha.at(0);
				}
			}
		else
			{
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			retorno = linha.at(0);
			}
		}
	delete teste;
	return (retorno);
	}

/**
 * Este método instância um objeto da classe RELATORIO.
 */
void PRINCIPAL::relatorio(int tipo)
	{
	int funcionario;

	funcionario = atoi(this->cod_func.c_str());
	this->Relatorio = new RELATORIO(this->conexao,funcionario,tipo);
	this->Relatorio->caixa = this->caixa;
	this->Relatorio->data_relatorio[0].append(hoje());
	this->Relatorio->janela();
	}

/**
 *
 */
void PRINCIPAL::baixar_debitos ()
	{
	this->janelas = 8;
	this->carregar_janela ();
	}

/**
 *
 */
void PRINCIPAL::preparar_dados (int dado)
	{
	string SQL, AUX;
	char *sql, *aux;
	int i, total;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	switch(dado)
		{
		case 1:
			{
			SQL.clear();
			SQL = "select clientes.cod_cli, clientes.nome from caixa.lancamentos natural join cadastro.clientes where lancamentos.e_s=1 and lancamentos.tipo='C' group by clientes.cod_cli, clientes.nome order by clientes.nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str ());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					this->conexao->resultado();
					for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->baixa_nome->append());
						celula[arvore_reg.cod_cli] = atoi(linha.at(0).c_str());
						celula[arvore_reg.descricao] = linha.at(1);
						}
					}
				else
					{
					celula = *(this->baixa_nome->append());
					celula[arvore_reg.cod_cli] = 0;
					celula[arvore_reg.descricao] = "Não há registros na base de dados";
					}
				}
			this->BNomes_List->set_text_column(arvore_reg.descricao);
			break;
			}
		}
	}

/**
 * \param e Gtk::Entry com o código ou nome do cliente.
 * \param modo inteiro que informa como será checado.\n
 * 1 - pelo Código
 * 2 - pelo Nome
 */
void PRINCIPAL::checar_debito (Gtk::Entry *e, int modo)
	{
	string SQL, AUX, codigo;
	char *sql, *aux;
	int i, total;
	float valor;
	vector<string> linha;

	AUX.clear();
	AUX = e->get_text();
	if (AUX.length() > 0)
		{
		SQL.clear();
		SQL = "select cod_cli, nome from cadastro.clientes where ";
		if (modo == 1)
			{
			SQL += "cod_cli="+AUX;
			}
		else if (modo == 2)
			{
			SQL += "nome='"+AUX+"'";
			}
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		else
			{
			this->conexao->resultado();
			linha = this->conexao->resultados.at(0);
			codigo.clear();
			codigo = linha.at(0);
			if (modo == 1)
				{
				AUX.clear();
				AUX = linha.at(1);
				this->BaixaB_Nome.set_text(Glib::ustring(AUX));
				}
			else if(modo == 2)
				{
				this->BaixaB_Codigo.set_text(Glib::ustring(codigo));
				}
			this->dados_debitos(codigo);
			}
		}
	else
		{
		if (modo == 1)
			{
			this->BaixaB.set_focus(this->BaixaB_Nome);
			}
		else if (modo == 2)
			{
			this->BaixaB.set_focus(this->BaixaB_Numero);
			}
		}
	}

/**
 *
 */
void PRINCIPAL::baixar_recibos ()
	{
	Gtk::TreeModel::Row reg;
	type_children::iterator i;
	string SQL, AUX, DATA;
	char *sql, *aux;
	int recibo;
	IMPRIMIR *print;

	type_children crianca = this->baixa_debitos->children();
	for(i = crianca.begin(); i != crianca.end(); ++i)
		{
  		reg = *i;
  		if(reg)
			{
			if (reg[arvore_reg.sel_recibo])
				{
				SQL.clear();
				SQL = "update caixa.lancamentos set tipo='D', data_qt='";
				AUX.clear();
				AUX = this->BaixaB_DataB.get_text();
				aux = new char[AUX.length()+1];
				strcpy(aux,AUX.c_str ());
				SQL.append(data_formatada(aux,1));
				delete aux;
				SQL += "' where e_s=1 and rec="+reg[arvore_reg.campo[1]]+" and data='";
				AUX.clear();
				AUX = ""+reg[arvore_reg.campo[1]];
				recibo = atoi(AUX.c_str());
				AUX.clear();
				AUX = ""+reg[arvore_reg.campo[0]];
				aux = new char[AUX.length()+1];
				strcpy(aux,AUX.c_str ());
				DATA.clear();
				DATA.append(data_formatada(aux,1));
				SQL.append(data_formatada(aux,1));
				delete aux;
				SQL += "';";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				this->conexao->executar(sql);
				delete sql;
				if (this->conexao->query_result == 3)
					{
					cout << this->conexao->mensagem << endl;
					}
				else
					{
					//cout << DATA << endl;
					//cout << recibo << endl;
					print = new IMPRIMIR(this->conexao,1,DATA,recibo);
					}
				}
			}
		}
	AUX.clear();
	AUX = this->BaixaB_Codigo.get_text();
	this->dados_debitos (AUX);
	}

/**
 * \param w Gtk::Entry passada por referência.
 * \param n posição que será assumida pelo cursor.
 */
void PRINCIPAL::set_posicao (Gtk::Entry * w, int n)
	{
	Glib::signal_idle().connect(sigc::bind_return(sigc::bind<int>(sigc::mem_fun (*w, &Gtk::Entry::set_position), n), false));
	}

/**
 * Checagem de máscara de Gtk::Entrys
 */
void PRINCIPAL::checagem(int onde)
	{
	string data_dg, mascara;
	int tam;
	bool mudou;
	mudou = false;
	if (this->entry_ativa != onde)
		{
		this->entry_ativa = onde;
		mudou = true;
		}
	switch(onde)
		{
		case 1:
			{
			if (mudou)
				{
				this->pos_entry = this->BaixaB_DataB.get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->BaixaB_DataB.get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->BaixaB_DataB.set_text(data_dg);
			this->set_posicao(&this->BaixaB_DataB,tam);
			this->pos_entry = tam;
			break;
			}
		case 2:
			{
			if (mudou)
				{
				this->pos_entry = this->Saldos_EData.get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->Saldos_EData.get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->Saldos_EData.set_text(data_dg);
			this->set_posicao(&this->Saldos_EData,tam);
			this->pos_entry = tam;
			break;
			}
		case 3:
			{
			if (mudou)
				{
				this->pos_entry = this->BaixaB_DataI.get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->BaixaB_DataI.get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->BaixaB_DataI.set_text(data_dg);
			this->set_posicao(&this->BaixaB_DataI,tam);
			this->pos_entry = tam;
			break;
			}
		case 4:
			{
			if (mudou)
				{
				this->pos_entry = this->BaixaB_DataF.get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->BaixaB_DataF.get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->BaixaB_DataF.set_text(data_dg);
			this->set_posicao(&this->BaixaB_DataF,tam);
			this->pos_entry = tam;
			break;
			}
		case 5:
			{
			if (mudou)
				{
				this->pos_entry = EA_Data->get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = EA_Data->get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			EA_Data->set_text(data_dg);
			this->set_posicao(EA_Data,tam);
			this->pos_entry = tam;
			break;
			}
		case 6:
			{
			if (mudou)
				{
				this->pos_entry = ER_Data->get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = ER_Data->get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			ER_Data->set_text(data_dg);
			this->set_posicao(ER_Data,tam);
			this->pos_entry = tam;
			break;
			}
		}
	}

/**
 * \param codigo refere-se ao código do cliente.
 */
void PRINCIPAL::dados_debitos(string codigo, int checar)
	{
	string SQL, AUX;
	char *sql, *aux;
	int i, total,it;
	float valor;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
	
	SQL.clear();
	SQL = "select lancamentos.rec, lancamentos.data, lancamentos.total, funcionario.u_login, clientes.nome from caixa.lancamentos inner join cadastro.funcionario on lancamentos.cod_fun=funcionario.cod_fun inner join cadastro.clientes on lancamentos.cod_cli=clientes.cod_cli where lancamentos.status and lancamentos.e_s=1 and lancamentos.tipo='C' and lancamentos.data>= '";
	AUX.clear();
	AUX = this->BaixaB_DataI.get_text ();
	aux = new char[20];
	strcpy(aux,AUX.c_str());
	SQL.append(data_formatada(aux,1));
	delete aux;
	SQL += "' and lancamentos.data<= '";
	AUX.clear();
	AUX = this->BaixaB_DataF.get_text ();
	aux = new char[20];
	strcpy(aux,AUX.c_str());
	SQL.append(data_formatada(aux,1));
	delete aux;
	if (checar == 1)
		{
		SQL += "' and lancamentos.cod_cli="+codigo;
		}
	else
		{
		SQL += "' and lancamentos.rec="+codigo;
		}
	SQL +=" order by lancamentos.data desc,lancamentos.rec desc";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		total = this->conexao->registros;
		this->conexao->resultado();
		this->baixa_debitos->clear();
		this->baixa_debitos = Gtk::ListStore::create(this->arvore_reg);
		this->T_Debitos.set_model(this->baixa_debitos);
		for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
			{
			linha = *ir;
			this->celula = *(this->baixa_debitos->append());
			this->celula[this->arvore_reg.sel_recibo] = false;
			aux = new char[32];
			strcpy(aux,linha.at(1).c_str());
			this->celula[this->arvore_reg.campo[0]] = data_formatada(aux,2);
			delete aux;
			this->celula[this->arvore_reg.campo[1]] = linha.at(0);
			AUX.clear();
			AUX = linha.at(2);
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,",");
				}
			valor = atof(AUX.c_str());
			aux = new char[32];
			sprintf(aux,"%.03f",valor);
			aux[strlen(aux)-1] = '\0';
			cout << __FILE__ << ": " << __LINE__ << endl;
			AUX.clear();
			AUX = casa_milhar(aux,0);
			delete aux;
			this->celula[this->arvore_reg.campo[2]] = AUX;
			this->celula[this->arvore_reg.campo[3]] = linha.at(3);
			this->celula[this->arvore_reg.campo[4]] = linha.at(4);
			}
		this->T_Debitos.remove_all_columns();
		this->T_Debitos.append_column_editable(Glib::ustring("Selecionar"), this->arvore_reg.sel_recibo);
		this->T_Debitos.append_column(Glib::ustring("Data"), this->arvore_reg.campo[0]);
		this->T_Debitos.append_column(Glib::ustring("Recibo"), this->arvore_reg.campo[1]);
		this->T_Debitos.append_column(Glib::ustring("Valor"), this->arvore_reg.campo[2]);
		this->T_Debitos.append_column(Glib::ustring("Funcionário"), this->arvore_reg.campo[3]);
		this->T_Debitos.append_column(Glib::ustring("Cliente"), this->arvore_reg.campo[4]);
		for(int i=0; i < 6; i++)
			{
			Gtk::TreeView::Column* coluna_temp = this->T_Debitos.get_column(i);
			coluna_temp->set_reorderable();	
			}
		}
	}

/**
 * \param codigo código do sistema de caixa para o serviço de saída.
 */
string PRINCIPAL::servico_saida(string codigo)
	{
	string SQL;
	char *sql;
	BANCOPG *saida;
	vector<string> linha;

	saida = new BANCOPG(CONF_FILE);
	SQL.clear();
	SQL = "select cod_serv from cadastro.servicos where e_s=2 and codigo="+codigo;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	saida->executar(sql);
	if (saida->query_result == 3)
		{
		cout << saida->mensagem << endl;
		SQL.clear(); 
		SQL = "não encontrado";
		}
	else
		{
		saida->resultado();
		linha = saida->resultados.at(0);
		SQL.clear();
		SQL = linha.at(0);
		}
	delete saida;
	return SQL;
	}

/**
 * Janela de Saldos do Sistema
 */
void PRINCIPAL::saldos_sistema ()
	{
	this->janelas = 9;
	this->saldo_pagina = 0;
	this->carregar_janela();
	}

/**
 *
 */
void PRINCIPAL::saldos(int acao)
	{
	string SQL, AUX;
	char *sql, *aux;
	float valor;
	int i, j, it;
	bool nega;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	this->saldo_alt = false;
	this->Saldos_EData.set_editable (false);
	this->Saldos_Atualizar.set_sensitive (false);
	this->Saldos_Alterar.set_sensitive (false);
	this->Saldos_Salvar.set_sensitive (false);
	SQL = "select count(*) from caixa.saldo";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		this->conexao->resultado();
		linha = this->conexao->resultados.at(0);
		this->saldo_total = atoi(linha.at(0).c_str());
		}
	switch(acao)
		{
		case 1:
			{
			aux = new char[10];
			sprintf(aux,"%d",this->saldo_pagina);
			SQL = "select * from caixa.saldo order by data desc limit 1 offset ";
			SQL.append (aux);
			delete aux;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				aux = new char[15];
				strcpy(aux,linha.at(0).c_str());
				this->Saldos_EData.set_text (Glib::ustring(data_formatada(aux,2)));
				delete aux;
				j = 1;
				for (i=0; i < 9; i++)
					{
					AUX.clear();
					AUX = linha.at(j);
					it = AUX.find(".");
					if (it != string::npos)
						{
						AUX.replace(it,1,",");
						}
					valor = atof(AUX.c_str());
					nega = false;
					if (valor < 0)
						{
						nega = true;
						valor = -valor;
						}
					aux = new char[32];
					sprintf (aux,"%0.2f",valor);
					cout << __FILE__ << ": " << __LINE__ << endl;
					AUX.clear();
					AUX = casa_milhar(aux,0);
					if (nega)
						{
						AUX = "-"+AUX;
						}
					this->Saldos_ESaldo[i].set_text(AUX);
					delete aux;
					j++;
					}
				}
			break;
			}
		}
	}

/**
 *
 */
void PRINCIPAL::saldos_paginar(int modo)
	{
	switch(modo)
		{
		case 1:
			{
			if (this->saldo_pagina < this->saldo_total)
				{
				this->saldo_pagina++;
				}
			break;
			}
		case 2:
			{
			if (this->saldo_pagina > 0)
				{
				this->saldo_pagina--;
				}
			break;
			}
		}
	this->saldos(1);
	}

/**
 *
 */
void PRINCIPAL::saldos_novo()
	{
	int i;

	this->Saldos_EData.set_text("");
	this->Saldos_EData.set_editable (true);
	this->Saldos_Atualizar.set_sensitive (true);
	for (i=0; i < 9; i++)
		{
		this->Saldos_ESaldo[i].set_text("");
		}
	this->Saldos.set_focus (this->Saldos_EData);
	}

/*
 *
 */
void PRINCIPAL::saldos_calcular(int atualizar=0)
	{
	string SQL, AUX, DATA;
	char *sql, *aux;
	int it;
	float valores[9];
	bool nega;
	BANCOPG *consultas;
	vector<string> linha;

	switch(atualizar)
		{
		case 0:
			{
			//rotina de atualização
			break;
			}
		case 1:
			{
			//rotina de inclusão
			AUX.clear();
			AUX = this->Saldos_EData.get_text ();
			SQL.clear();
			SQL = "select saldo_sis from caixa.saldo where data < '";
			aux = new char[AUX.length()+3];
			strcpy(aux,AUX.c_str());
			aux = data_formatada(aux,2);
			DATA.clear();
			DATA.append(aux);
			delete aux;
			SQL += DATA + "' order by data desc";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				this->conexao->resultado();
				linha = this->conexao->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,",");
					}
				valores[0] = atof(AUX.c_str());
				nega = false;
				if (valores[0] < 0)
					{
					nega = true;
					valores[0] = -valores[0];
					}	
				aux = new char[32];
				sprintf(aux,"%.02f",valores[0]);
				AUX.clear();
				AUX = casa_milhar(aux,0);
				if (nega)
					{
					valores[0] = -valores[0];
					AUX = "-"+AUX;
					}
				this->Saldos_ESaldo[0].set_text(AUX);
				SQL.clear();
				SQL = "select sum(total) from caixa.lancamentos where e_s=1 and tipo='D' and data_qt='"+DATA+"' and status ";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				consultas = new BANCOPG(CONF_FILE);
				consultas->executar(sql);
				delete sql;
				consultas->resultado();
				linha = consultas->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,",");
					}
				delete consultas;
				valores[1] = atof(AUX.c_str());
				SQL.clear();
				SQL = "select sum(total) from caixa.lancamentos where e_s=2 and data='"+DATA+"' and status ";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				consultas = new BANCOPG(CONF_FILE);
				consultas->executar(sql);
				delete sql;
				consultas->resultado();
				linha = consultas->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,",");
					}
				delete consultas;
				valores[2] = atof(AUX.c_str());
				nega = false;
				if (valores[1] < 0)
					{
					nega = true;
					valores[1] = -valores[1];
					}
				aux = new char[32];
				sprintf(aux,"%.02f",valores[1]);
				AUX.clear();
				AUX = casa_milhar(aux,0);
				if (nega)
					{
					valores[1] = -valores[1];
					AUX = "-"+AUX;
					}
				this->Saldos_ESaldo[1].set_text(AUX);
				delete aux;
				nega = false;
				if (valores[2] < 0)
					{
					nega = true;
					valores[2] = -valores[2];
					}
				aux = new char[32];
				sprintf(aux,"%.02f",valores[2]);
				AUX.clear();
				AUX = casa_milhar(aux,0);
				if (nega)
					{
					valores[2] = -valores[2];
					AUX = "-"+AUX;
					}
				this->Saldos_ESaldo[2].set_text(AUX);
				delete aux;
				valores[3] = valores[0] + valores[1] - valores[2];
				nega = false;
				if (valores[3] < 0)
					{
					nega = true;
					valores[3] = -valores[3];
					}
				aux = new char[32];
				sprintf(aux,"%.02f",valores[3]);
				AUX.clear();
				AUX = casa_milhar(aux,0);
				if (nega)
					{
					valores[3] = -valores[3];
					AUX = "-"+AUX;
					}
				this->Saldos_ESaldo[3].set_text(AUX);
				delete aux;
				this->Saldos.set_focus (this->Saldos_ESaldo[8]);
				}
			break;
			}
		case 2:
			{
			//rotina calculo saldo real
			AUX.clear();
			AUX = this->Saldos_ESaldo[3].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[3] = atof(AUX.c_str());
			cout << valores[3] << endl;
			AUX.clear();
			AUX = this->Saldos_ESaldo[4].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[4] = atof(AUX.c_str());
			cout << valores[4] << endl;
			AUX.clear();
			AUX = this->Saldos_ESaldo[5].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[5] = atof(AUX.c_str());
			cout << valores[5] << endl;
			aux = new char[32];
			sprintf(aux,"%.02f",valores[5]);
			this->Saldos_ESaldo[5].set_text(casa_milhar(aux,0));
			delete aux;
			valores[6] = valores[4] + valores[5];
			cout << valores[6] << endl;
			aux = new char[32];
			sprintf(aux,"%.02f",valores[6]);
			this->Saldos_ESaldo[6].set_text(casa_milhar(aux,0));
			delete aux;
			valores[7] = valores[6] - valores[3];
			nega = false;
			if (valores[7] < 0)
				{
				nega = true;
				valores[7] = -valores[7];
				}
			cout << valores[7] << endl;
			aux = new char[32];
			sprintf(aux,"%.02f",valores[7]);
			AUX.clear();
			AUX = casa_milhar(aux,0);
			if (nega)
				{
				valores[7] = -valores[7];
				AUX = "-"+AUX;
				}
			this->Saldos_ESaldo[7].set_text(AUX);
			delete aux;
			if (this->saldo_alt)
				{
				this->Saldos_Alterar.set_sensitive (true);
				this->Saldos.set_focus(this->Saldos_Alterar);
				}
			else
				{
				this->Saldos_Salvar.set_sensitive (true);
				this->Saldos.set_focus(this->Saldos_Salvar);
				}
			break;
			}
		case 3:
			{
			AUX.clear();
			AUX = this->Saldos_ESaldo[0].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[0] = atof(AUX.c_str());
			AUX.clear();
			AUX = this->Saldos_ESaldo[1].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[1] = atof(AUX.c_str());
			AUX.clear();
			AUX.clear();
			AUX = this->Saldos_ESaldo[2].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[2] = atof(AUX.c_str());
			AUX.clear();
			AUX = this->Saldos_ESaldo[8].get_text();
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,"");
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				}
			valores[8] = atof(AUX.c_str());
			aux = new char[64];
			sprintf(aux,"%.02f",valores[8]);
			this->Saldos_ESaldo[8].set_text(casa_milhar(aux,0));
			delete aux;
			valores[3] = valores[0] + (valores[1]+valores[8]) - valores[2];
			nega = false;
			if (valores[3] < 0)
				{
				nega = true;
				valores[3] = -valores[3];
				}
			aux = new char[64];
			sprintf(aux,"%.02f",valores[3]);
			AUX.clear();
			AUX = casa_milhar(aux,0);
			delete aux;
			if (nega)
				{
				valores[3] = -valores[3];
				AUX = "-"+AUX;
				}
			this->Saldos_ESaldo[3].set_text(AUX);
			this->Saldos.set_focus (this->Saldos_ESaldo[4]);
			break;
			}
		}
	}

/**
 *
 */
void PRINCIPAL::saldos_salvar()
	{
	string SQL,  DATA;
	char *sql, *aux;
	string valores[9];
	int i,it;

	SQL.clear();
	SQL = "insert into caixa.saldo values('";
	DATA.clear();
	DATA = this->Saldos_EData.get_text();
	aux = new char[32];
	strcpy(aux,DATA.c_str());
	DATA.clear();
	DATA.append(data_formatada(aux,1));
	delete aux;
	SQL += DATA+"','";
	for (i=0; i < 9; i++)
		{
		valores[i].clear();
		valores[i] = this->Saldos_ESaldo[i].get_text ();
		it = valores[i].find(".");
		if (it != string::npos)
			{
			valores[i].replace(it,1,"");
			it = valores[i].find(".");
			if (it != string::npos)
				{
				valores[i].replace(it,1,"");
				}
			}
		it = valores[i].find(",");
		if (it != string::npos)
			{
			valores[i].replace(it,1,".");
			}
		if (i < 8)
			{
			SQL += valores[i] + "','";
			}
		else
			{
			SQL += valores[i] + "');";
			}
		}
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	cout << sql <<endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	this->saldos(1);
	}

/**
 *
 */
void PRINCIPAL::saldos_alterar()
	{
	this->saldo_alt = true;
	this->Saldos_EData.set_editable (false);
	this->Saldos_Atualizar.set_sensitive (true);
	//this->Saldos_Alterar.set_sensitive (true);
	this->Saldos.set_focus(this->Saldos_Atualizar);
	}

void PRINCIPAL::saldos_salvarA()
	{
	string SQL,  DATA;
	char *sql, *aux;
	string valores[9], campos[] = {"saldo_ant","entradas","saidas","saldo_sis","saldo_ch","saldo_din","saldo_real","diferenca","saldo_online"};
	int i,it;

	SQL.clear();
	SQL = "update caixa.saldo set ";
	DATA.clear();
	DATA = this->Saldos_EData.get_text();
	aux = new char[32];
	strcpy(aux,DATA.c_str());
	DATA.clear();
	DATA.append(data_formatada(aux,1));
	delete aux;
	for (i=0; i < 9; i++)
		{
		valores[i].clear();
		valores[i] = this->Saldos_ESaldo[i].get_text ();
		it = valores[i].find(".");
		if (it != string::npos)
			{
			valores[i].replace(it,1,"");
			it = valores[i].find(".");
			if (it != string::npos)
				{
				valores[i].replace(it,1,"");
				}
			}
		it = valores[i].find(",");
		if (it != string::npos)
			{
			valores[i].replace(it,1,".");
			}
		if (i < 8)
			{
			SQL += campos[i]+"='"+valores[i] + "',";
			}
		else
			{
			SQL += campos[i]+"='"+valores[i] + "' ";
			}
		}
	SQL += "where data='"+DATA+"'";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	this->saldos(1);
	}

/**
 *
 */
void PRINCIPAL::tabular2 (Gtk::Window *w, Gtk::Widget *e)
	{
	w->set_focus(*e);
	}

/**
 *
 */
void PRINCIPAL::checagem_impostoT ()
	{
	Gtk::Window *Progresso;
	Gtk::VBox *Barras;
	Gtk::HBox *H_Botao;
	Gtk::Button *Botao;
	Gtk::Frame *F_Progresso;

	Progresso = new Gtk::Window();
	Progresso->set_title(Glib::ustring("Checagem de Imposto"));
	Progresso->set_position (Gtk::WIN_POS_CENTER);
	Progresso->set_type_hint (Gdk::WINDOW_TYPE_HINT_DIALOG);
	Glib::signal_timeout().connect(sigc::mem_fun(*this,&PRINCIPAL::progresso_checagem), 50);
	Barras = new Gtk::VBox(false,0);
	F_Progresso = new Gtk::Frame(Glib::ustring("Processo Geral"));
	P_Barras = new Gtk::ProgressBar ();
	P_Barras->set_fraction(0.0);
	F_Progresso->add(*P_Barras);
	Barras->pack_start (*F_Progresso,true,true,0);
	H_Botao = new Gtk::HBox(false,0);
	Botao = new Gtk::Button(Glib::ustring("Funjecc 10%"));
	Botao->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checagem_imposto),1));
	H_Botao->pack_start (*Botao,true,true,0);
	Botao = new Gtk::Button(Glib::ustring("ISSQN 5%"));
	Botao->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checagem_imposto),2));
	H_Botao->pack_start (*Botao,true,true,0);
	Barras->pack_start (*H_Botao,true,true,0);
	Progresso->add(*Barras);
	Progresso->show_all();
	Gtk::Main::run(*Progresso);
	}

/**
 * /param imposto indicativo de qual checagem será feita.\n 1 - Funjecc 10%\n 2 - ISSQN 5%
 */
void PRINCIPAL::checagem_imposto (int imposto)
	{
	int i, total, it;
	string SQL, AUX;
	char *sql, *aux;
	float valor, valor_a, cresc;
	string codigo, campo;
	BANCOPG *checa, *grava;
	vector<vector<string> >::iterator ir, ir2;
	vector<string> linha, linha2;

	checa = new BANCOPG(CONF_FILE);
	grava = new BANCOPG(CONF_FILE);
	SQL.clear();
	switch(imposto)
		{
		case 1:
			{
			SQL = "select rec, data, total_liq from caixa.entrada where cod_serv=22 order by rec";
			codigo.clear();
			codigo = "22";
			campo.clear();
			campo="funjecc10";
			break;
			}
		case 2:
			{
			SQL = "select rec, data, total_liq from caixa.entrada where cod_serv=223 order by rec";
			codigo.clear();
			codigo = "223";
			campo.clear();
			campo="issqn";
			break;
			}
		}
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		total = this->conexao->registros;
		this->conexao->resultado();
		fator_prog = 1.0/total;
		cresc = fator_prog;
		for (ir=this->conexao->resultados.begin(); ir < this->conexao->resultados.end(); ir++)
			{
			linha = *ir;
			AUX.clear();
			AUX = linha.at(2);
			it = AUX.find(".");
			if (it != string::npos)
				{
				AUX.replace(it,1,",");
				}
			valor = atof(AUX.c_str());
			SQL.clear();
			SQL = "select entrada.cod_serv, entrada."+campo+" from caixa.entrada inner join cadastro.servicos on entrada.cod_serv=servicos.cod_serv where servicos.f10 and entrada.rec=";
			SQL += linha.at(0);
			SQL += " and entrada.data='";
			SQL += linha.at(1);
			SQL +="'";
			//cout << SQL << endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			checa->executar(sql);
			delete sql;
			//cout << checa->query_result << endl;
			if (checa->query_result == 3)
				{
				cout << checa->mensagem << endl;
				}
			else
				{
				checa->resultado();
				linha2 = checa->resultados.at(0);
				AUX.clear();
				AUX = linha2.at(1);
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,",");
					}
				valor_a = atof(AUX.c_str());
				valor += valor_a;
				aux = new char[32];
				sprintf(aux,"%0.2f",valor);
				//aux[strlen(aux)-1] = '\0';
				SQL.clear();
				SQL = "update caixa.entrada set "+campo+"='";
				SQL += valor_formatado(aux,1);
				delete aux;
				SQL += "' where rec=";
				SQL += linha.at(0);
				SQL += " and entrada.data='";
				SQL += linha.at(1);
				SQL +="' and cod_serv=";
				SQL += linha2.at(0);
				SQL +="; delete from caixa.entrada where rec=";
				SQL += linha.at(0);
				SQL += " and entrada.data='";
				SQL += linha.at(1);
				SQL +="' and cod_serv="+codigo;
				//cout << SQL << endl;
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				grava->executar(sql);
				if (grava->query_result == 3)
					{
					cout << grava->mensagem << endl;
					}
				else
					{
					fator_prog += cresc;
					}
				}
			}
		}
	delete checa, grava;
	}

/* Update the value of the progress bar so that we get
 * some movement */
bool PRINCIPAL::progresso_checagem()
	{
    P_Barras->set_fraction(this->fator_prog);
 	return true;
	}

/**
 *
 */
void PRINCIPAL::checar_recibo()
	{
	string AUX;
	/*char *sql;

	AUX.clear();
	AUX = this->BaixaB_Numero.get_text();
	SQL = "select cod_cli from caixa.lancamentos where rec="+AUX+" data >= '";
	AUX.clear();
	AUX = this->BaixaB_DataI.get_text();
	SQL += AUX + "' and data <='";
	AUX.clear();
	AUX = this->BaixaB_DataF.get_text();
	SQL += AUX + "'";
	cout << SQL << endl;
	*/
	AUX.clear();
	AUX = this->BaixaB_Numero.get_text();
	this->dados_debitos (AUX,2);
	}

void PRINCIPAL::ajustar_centavos ()
	{
	int resposta;
	string senha("160"), digitado;
	Gtk::Label Lcod;
	Gtk::Entry Ecod;
	Gtk::HBox HDcod;

	Gtk::Dialog *DCod = new Gtk::Dialog(Glib::ustring("Código de Liberação"), false, false);
	DCod->add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
	DCod->set_position(Gtk::WIN_POS_CENTER);
	DCod->set_icon(ponteiro_icon);
	HDcod.set_homogeneous(false);
	HDcod.set_spacing(8);
	HDcod.set_border_width(8);
	DCod->get_vbox()->pack_start(HDcod, false, false);
	Lcod.set_label(Glib::ustring("Senha:"));
	Ecod.set_visibility(false);	
	Ecod.set_invisible_char('*');
	Ecod.signal_activate ().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::tabular2),DCod, DCod->get_widget_for_response(Gtk::RESPONSE_OK)));
	HDcod.pack_start(Lcod,false,false,0);
	HDcod.pack_start(Ecod,false,false,0);
	HDcod.show_all();
	resposta = DCod->run();
	switch(resposta)
		{
		case Gtk::RESPONSE_OK:
			{
			digitado.clear();
			digitado = Ecod.get_text();
			if (senha.compare(digitado) == 0)
				{
				DCod->hide();
				Editar = new Gtk::Window();
				Editar->set_title (Glib::ustring("..::Ajuste de Recibos::.."));
				Editar->set_size_request (-1,-1);
				Editar->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),10));
				Editar->signal_show().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),0));
				Editar->set_position(Gtk::WIN_POS_CENTER);
				Editar->set_icon(ponteiro_icon);
				VB_Ajuste = new Gtk::VBox(false,0);
				HB_Ajuste = new Gtk::HBox(false,0);
				L_Ajuste = new Gtk::Label(Glib::ustring("Tipo:"));
				HB_Ajuste->pack_start(*L_Ajuste,false,false,0);
				CBA_Tipo = new Gtk::ComboBoxText ();
				CBA_Tipo->append_text ("");
				CBA_Tipo->append_text ("Entrada");
				CBA_Tipo->append_text ("Saída");
				CBA_Tipo->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),1));
				HB_Ajuste->pack_start(*CBA_Tipo,false,false,0);
				L_Ajuste = new Gtk::Label(Glib::ustring("Data: "));
				HB_Ajuste->pack_start(*L_Ajuste,false,false,0);
				EA_Data = new Gtk::Entry();
				EA_Data->set_size_request (120,-1);
				EA_Data->set_max_length (10);
				EA_Data->signal_changed ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checagem),5));
				EA_Data->signal_activate ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),2));
				HB_Ajuste->pack_start(*EA_Data,false,false,0);
				L_Ajuste = new Gtk::Label(Glib::ustring("Recibo: "));
				HB_Ajuste->pack_start(*L_Ajuste,false,false,0);
				EA_Recibo = new Gtk::Entry();
				EA_Recibo->set_size_request (120,-1);
				EA_Recibo->signal_changed ().connect(sigc::bind<Gtk::Entry*,int>(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),EA_Recibo,2));
				EA_Recibo->signal_activate ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),3));
				HB_Ajuste->pack_start(*EA_Recibo,false,false,0);
				VB_Ajuste->pack_start(*HB_Ajuste,false,false,0);
				HB_Ajuste = new Gtk::HBox(false,0);
				L_Ajuste = new Gtk::Label(Glib::ustring("Valor Total R$ "));
				HB_Ajuste->pack_start(*L_Ajuste,false,false,0);
				EA_Valor = new Gtk::Entry();
				EA_Valor->set_size_request (150,-1);
				HB_Ajuste->pack_start(*EA_Valor,false,false,0);
				VB_Ajuste->pack_start(*HB_Ajuste,false,false,0);
				HSP_Ajuste = new Gtk::HSeparator ();
				VB_Ajuste->pack_start(*HSP_Ajuste,true,true,0);
				HB_Ajuste = new Gtk::HBox(false,0);
				BTOK_Ajuste = new Gtk::Button(Gtk::Stock::SAVE);
				BTOK_Ajuste->signal_clicked ().connect (sigc::mem_fun(*this,&PRINCIPAL::salvar_ajuste));
				BTOK_Ajuste->set_sensitive (false);
				BTOUT_Ajuste = new Gtk::Button(Gtk::Stock::NEW);
				BTOUT_Ajuste->signal_clicked ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),10));
				BTOUT_Ajuste->set_sensitive (false);
				BTIMP_Ajuste = new Gtk::Button(Gtk::Stock::PRINT);
				BTIMP_Ajuste->signal_clicked ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),4));
				BTIMP_Ajuste->set_sensitive (false);
				EA_Valor->signal_activate ().connect (sigc::bind<Gtk::Window *, Gtk::Widget*>(sigc::mem_fun(*this,&PRINCIPAL::tabular2),Editar,BTOK_Ajuste));
				HB_Ajuste->pack_start(*BTOK_Ajuste,false,false,0);
				HB_Ajuste->pack_start(*BTOUT_Ajuste,false,false,0);
				HB_Ajuste->pack_start(*BTIMP_Ajuste,false,false,0);
				VB_Ajuste->pack_start(*HB_Ajuste,false,false,0);
				Editar->add(*VB_Ajuste);
				Editar->show_all();
				Gtk::Main::run(*Editar);
				}
			else
				{
				tabular2(DCod, &Ecod);
				}
			break;
			}
		default:
			{
			DCod->hide();
			break;
			}
		}
	}

void PRINCIPAL::dados_ajuste(int opc)
	{
	string SQL, AUX, tipo_e, data, recibo;
	char *sql, *aux;
	int i, total, tipo, rec;
	float valor;
	vector<string> linha;
	vector<vector<string> >::iterator ir;
	IMPRIMIR *print;
	
	if (opc < 5)
		{
		AUX.clear();
		AUX = CBA_Tipo->get_active_text();
		tipo_e.clear();
		tipo_e = "2";
		tipo = 2;
		if (AUX.compare("Entrada") == 0)
			{
			tipo_e.clear();
			tipo_e = "1";
			tipo = 1;
			}
		}
	else
		{
		tipo = 1;
		tipo_e.clear();
		tipo_e = "1";
		}
	switch (opc)
		{
		case 0:
		case 10:
			{
			if (opc != 10)
				{
				EA_Data->set_editable(false);
				EA_Recibo->set_editable(false);
				EA_Data->set_text("");
				CBA_Tipo->set_active (0);
				}
			CBA_Tipo->set_sensitive (true);
			EA_Valor->set_editable(false);
			EA_Recibo->set_text("");
			EA_Valor->set_text("");
			BTOK_Ajuste->set_sensitive (false);
			BTOUT_Ajuste->set_sensitive (false);
			BTIMP_Ajuste->set_sensitive (false);
			tabular2(Editar,EA_Data);
			break;
			}
		case 1:
		case 5:
			{
			if (opc != 5)
				{
				ECA_Data = Gtk::EntryCompletion::create();
				EA_Data->set_completion (ECA_Data);
				ajuste_dataref = Gtk::ListStore::create(arvore_reg);
				ECA_Data->set_model(ajuste_dataref);
				}
			else
				{
				ECR_Data = Gtk::EntryCompletion::create ();
				ER_Data->set_completion (ECR_Data);
				re_dataref = Gtk::ListStore::create (arvore_reg);
				ECR_Data->set_model (re_dataref);
				}
			SQL.clear();
			SQL = "select distinct data from caixa.lancamentos where e_s="+tipo_e+" order by data desc";
			//cout << SQL << endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			conexao->executar(sql);
			delete sql;
			//cout << conexao->registros << endl;
			if (conexao->registros > 0)
				{
				conexao->resultado();
				for (ir=conexao->resultados.begin(),i=0; ir < conexao->resultados.end(); ir++,i++)
					{
					linha = *ir;
					AUX.clear();
					aux = new char[32];
					strcpy(aux,linha.at(0).c_str());
					//cout << aux << endl;
					AUX.append(data_formatada(aux,2));
					//cout << AUX << endl;
					delete aux;
					if (opc != 5)
						{
						celula = *(this->ajuste_dataref->append());
						}
					else
						{
						celula = *(re_dataref->append());
						}
					celula[arvore_reg.descricao] = AUX;
					}
				}
			else
				{
				if (opc != 5)
					{
					celula = *(this->ajuste_dataref->append());
					}
				else
					{
					celula = *(re_dataref->append());
					}
				celula[arvore_reg.descricao] = conexao->mensagem;
				}
			if (opc != 5)
				{
				ECA_Data->set_text_column(arvore_reg.descricao);
				EA_Data->set_editable(true);
				tabular2(Editar,EA_Data);
				}
			else
				{
				ECR_Data->set_text_column(arvore_reg.descricao);
				ER_Data->set_editable(true);
				tabular2(Editar,ER_Data);
				}
			break;
			}
		case 2:
		case 6:
			{
			//Checagem da data
			AUX.clear();
			if (opc != 6)
				{
				AUX = EA_Data->get_text();
				}
			else
				{
				AUX = ER_Data->get_text();
				}
			aux = new char[32];
			strcpy(aux,AUX.c_str());
			data.clear();
			data.append(data_formatada(aux,1));
			delete aux;
			SQL.clear();
			SQL = "select count(*) from caixa.lancamentos where e_s="+tipo_e+" and data='"+data+"'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			conexao->executar(sql);
			delete sql;
			conexao->resultado();
			linha.clear();
			linha = conexao->resultados.at(0);
			total = atoi(linha.at(0).c_str());
			if (total > 0)
				{
				if (opc != 6)
					{
					ECA_Recibo = Gtk::EntryCompletion::create();
					EA_Recibo->set_completion (ECA_Recibo);
					ajuste_reciboref = Gtk::ListStore::create(arvore_reg);
					ECA_Recibo->set_model(ajuste_reciboref);
					}
				else
					{
					ECR_Recibo = Gtk::EntryCompletion::create();
					ER_Recibo->set_completion (ECR_Recibo);
					re_reciboref = Gtk::ListStore::create(arvore_reg);
					ECR_Recibo->set_model(re_reciboref);
					}
				SQL.clear();
				SQL = "select distinct rec from caixa.lancamentos where e_s="+tipo_e+" and data='"+data+"' order by rec desc";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				conexao->executar(sql);
				if (conexao->registros > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						if (opc != 6)
							{
							celula = *(ajuste_reciboref->append());
							}
						else
							{
							celula = *(re_reciboref->append());
							}
						celula[arvore_reg.descricao] = linha.at(0);
						}
					if (opc != 6)
						{
						ECA_Recibo->set_text_column (arvore_reg.descricao);
						EA_Recibo->set_editable(true);
						tabular2(Editar,EA_Recibo);
						}
					else
						{
						ECR_Recibo->set_text_column (arvore_reg.descricao);
						ER_Recibo->set_editable(true);
						tabular2(Editar,ER_Recibo);
						}
					}
				else
					{
					Gtk::MessageDialog dialog(*Editar, Glib::ustring("Sem Recibos"), false, Gtk::MESSAGE_ERROR);
					dialog.set_secondary_text(Glib::ustring("Por favor informe uma data válida"));
					dialog.run();
					if (opc != 6)
						{
						EA_Data->set_text("");
						tabular2(Editar,EA_Data);
						}
					else
						{
						ER_Data->set_text("");
						tabular2(Editar,ER_Data);
						}
					}
				}
			else
				{
				Gtk::MessageDialog dialog(*Editar, Glib::ustring("Data Inválida"), false, Gtk::MESSAGE_ERROR);
				dialog.set_secondary_text(Glib::ustring("Por favor informe uma data válida"));
				dialog.run();
				if (opc != 6)
					{
					EA_Data->set_text("");
					tabular2(Editar,EA_Data);
					}
				else
					{
					ER_Data->set_text("");
					tabular2(Editar,ER_Data);
					}
				}
			break;
			}
		case 3:
		case 7:
			{
			AUX.clear();
			recibo.clear();
			if (opc != 7)
				{
				AUX = EA_Data->get_text();
				recibo = EA_Recibo->get_text();
				}
			else
				{
				AUX = ER_Data->get_text();
				recibo = ER_Recibo->get_text();
				}
			aux = new char[32];
			strcpy(aux,AUX.c_str());
			data.clear();
			data.append(data_formatada(aux,1));
			delete aux;
			SQL.clear();
			SQL = "select count(*) from caixa.lancamentos where e_s="+tipo_e+" and data='"+data+"' and rec="+recibo;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			conexao->executar(sql);
			delete sql;
			conexao->resultado();
			linha.clear();
			linha = conexao->resultados.at(0);
			total = atoi(linha.at(0).c_str());
			if (total > 0)
				{
				if (opc != 7)
					{
					BTOK_Ajuste->set_sensitive (true);
					}
				else
					{
					BTR_Adicionar->set_sensitive (true);
					}
				SQL.clear();
				SQL = "select total from caixa.lancamentos where e_s="+tipo_e+" and data='"+data+"' and rec="+recibo;
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				conexao->executar(sql);
				delete sql;
				conexao->resultado();
				linha.clear();
				linha = conexao->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				if (opc != 7)
					{
					EA_Valor->set_text(AUX);
					EA_Valor->set_editable(true);
					tabular2(Editar,EA_Valor);
					}
				else
					{
					ER_Valor.clear();
					ER_Valor = AUX;
					tabular2(Editar,BTR_Adicionar);
					}
				}
			else
				{
				Gtk::MessageDialog dialog(*Editar, Glib::ustring("Recibo Inválido"), false, Gtk::MESSAGE_ERROR);
				AUX.clear();
				AUX = "Por favor informe um recibo válido para esta data\n";
				aux = new char[32];
				strcpy(aux,data.c_str());
				AUX.append(data_formatada(aux,2));
				delete aux;
				dialog.set_secondary_text(Glib::ustring(AUX));
				dialog.run();
				if (opc != 7)
					{
					EA_Recibo->set_text("");
					tabular2(Editar,EA_Recibo);
					}
				else
					{
					ER_Recibo->set_text("");
					tabular2(Editar,ER_Recibo);
					}
				}
			break;
			}
		case 4:
			{
			AUX.clear();
			AUX = EA_Data->get_text();
			aux = new char[32];
			strcpy(aux,AUX.c_str());
			data.clear();
			data.append(data_formatada(aux,1));
			delete aux;
			recibo.clear();
			recibo = EA_Recibo->get_text();
			rec = atoi(recibo.c_str());
			print = new IMPRIMIR(conexao,tipo,data,rec);
			BTIMP_Ajuste->set_sensitive (false);
			tabular2(Editar,BTOUT_Ajuste);
			break;
			}
		}
	}

void PRINCIPAL::salvar_ajuste ()
	{
	string SQL, AUX, tipo_e, data, recibo, valor;
	char *sql, *aux;

	AUX.clear();
	AUX = CBA_Tipo->get_active_text();
	tipo_e.clear();
	tipo_e = "2";
	if (AUX.compare("Entrada") == 0)
		{
		tipo_e.clear();
		tipo_e = "1";
		}
	AUX.clear();
	AUX = EA_Data->get_text();
	aux = new char[32];
	strcpy(aux,AUX.c_str());
	data.clear();
	data.append(data_formatada(aux,1));
	delete aux;
	recibo.clear();
	recibo = EA_Recibo->get_text();
	valor.clear();
	valor = EA_Valor->get_text();
	SQL.clear();
	SQL = "update caixa.lancamentos set total='"+valor+"' where e_s="+tipo_e+" and data='"+data+"' and rec="+recibo;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	conexao->executar(sql);
	if (conexao->query_result == 3)
		{
		Gtk::MessageDialog dialog(*Editar, Glib::ustring("Erro ao Salvar"), false, Gtk::MESSAGE_ERROR);
		AUX.clear();
		AUX = "Verifique os dados!\n";
		AUX += conexao->mensagem;
		dialog.set_secondary_text(Glib::ustring(AUX));
		dialog.run();
		}
	else
		{
		CBA_Tipo->set_sensitive (false);
		EA_Data->set_editable(false);
		EA_Recibo->set_editable(false);
		EA_Valor->set_editable(false);
		BTOK_Ajuste->set_sensitive (false);
		BTOUT_Ajuste->set_sensitive (true);
		BTIMP_Ajuste->set_sensitive (true);
		tabular2(Editar,BTIMP_Ajuste);
		}
	}

void PRINCIPAL::imprimir_credLote ()
	{
	Gtk::HBox *H_Box;
	Gtk::VBox *V_Box;
	Gtk::Label *L_Texto;
	int i;

	total_recibos = 0;
	Editar = new Gtk::Window();
	Editar->set_title (Glib::ustring("..::Recibos - Re-Impressão::.."));
	Editar->set_size_request (-1,200);
	Editar->signal_hide().connect(sigc::bind(sigc::mem_fun(*this,&PRINCIPAL::sair),10));
	Editar->signal_show().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),5));
	Editar->set_position(Gtk::WIN_POS_CENTER);
	Editar->set_icon(ponteiro_icon);
	V_Box = new Gtk::VBox(false,0);
	H_Box = new Gtk::HBox(false,0);
	L_Texto = new Gtk::Label("Data: ");
	ER_Data = new Gtk::Entry();
	ER_Data->set_size_request (120,-1);
	ER_Data->set_max_length (10);
	ER_Data->signal_changed ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::checagem),6));
	ER_Data->signal_activate ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),6));
	H_Box->pack_start(*L_Texto,false,false,0);
	H_Box->pack_start(*ER_Data,false,false,0);
	L_Texto = new Gtk::Label("Recibo: ");
	ER_Recibo = new Gtk::Entry();
	ER_Recibo->set_size_request (120,-1);
	ER_Recibo->signal_changed ().connect(sigc::bind<Gtk::Entry*,int>(sigc::mem_fun(*this,&PRINCIPAL::checar_digito),ER_Recibo,2));
	ER_Recibo->signal_activate ().connect(sigc::bind<int>(sigc::mem_fun(*this,&PRINCIPAL::dados_ajuste),7));
	H_Box->pack_start(*L_Texto,false,false,0);
	H_Box->pack_start(*ER_Recibo,false,false,0);
	V_Box->pack_start(*H_Box,false,false,0);
	H_Box = new Gtk::HBox(false,0);
	BTR_Adicionar = new Gtk::Button(Gtk::Stock::ADD);
	BTR_Remover = new Gtk::Button(Gtk::Stock::REMOVE);
	BTR_Imprimir = new Gtk::Button(Gtk::Stock::PRINT);
	BTR_Adicionar->set_sensitive (false);
	BTR_Adicionar->signal_clicked ().connect (sigc::mem_fun(*this,&PRINCIPAL::adicionar_recibo));
	BTR_Remover->set_sensitive (false);
	BTR_Remover->signal_clicked ().connect (sigc::mem_fun(*this,&PRINCIPAL::remover_recibo));
	BTR_Imprimir->set_sensitive (false);
	BTR_Imprimir->signal_clicked ().connect (sigc::mem_fun(*this,&PRINCIPAL::imprimir_recibos));
	H_Box->pack_start(*BTR_Adicionar,false,false,0);
	H_Box->pack_start(*BTR_Remover,false,false,0);
	H_Box->pack_start(*BTR_Imprimir,false,false,0);
	V_Box->pack_start(*H_Box,false,false,0);
	S_Recs = new Gtk::ScrolledWindow();
	S_Recs->set_policy (Gtk::POLICY_AUTOMATIC,Gtk::POLICY_AUTOMATIC);
	T_Recs = new Gtk::TreeView ();
	re_impressao = Gtk::ListStore::create(arvore_reg);
	T_Recs->set_model(re_impressao);
	T_Recs->signal_row_activated ().connect (sigc::mem_fun(*this,&PRINCIPAL::selecionar_recibo));
	T_Recs->remove_all_columns ();
	T_Recs->append_column_numeric (Glib::ustring("Tipo"), arvore_reg.tipo, "%d");
	T_Recs->append_column (Glib::ustring("Data"), arvore_reg.data);
	T_Recs->append_column_numeric (Glib::ustring("Recibo"), arvore_reg.recibo, "%d");
	T_Recs->append_column_numeric (Glib::ustring("Valor"), arvore_reg.valor, "%0.2f");
	for(i=0; i < 4; i++)
		{
		Gtk::TreeView::Column* coluna_temp = T_Recs->get_column(i);
		coluna_temp->set_reorderable();	
		}
	S_Recs->add(*T_Recs);
	V_Box->pack_start(*S_Recs);
	
	Editar->add(*V_Box);
	Editar->show_all();
	Gtk::Main::run(*Editar);
	}

void PRINCIPAL::adicionar_recibo ()
	{
	int tipo, recibo;
	float valor;
	string data, AUX;
	int it;

	total_recibos++;
	tipo = 1;
	data.clear();
	data = ER_Data->get_text();
	AUX.clear();
	AUX = ER_Recibo->get_text();
	recibo = atoi(AUX.c_str());
	it = ER_Valor.find(".");
	if (it != string::npos)
		{
		ER_Valor.replace(it,1,",");
		}
	valor = atof(ER_Valor.c_str());
	celula = *(re_impressao->append());
	celula[arvore_reg.tipo] = tipo;
	celula[arvore_reg.data] = data;
	celula[arvore_reg.recibo] = recibo;
	celula[arvore_reg.valor] = valor;

	BTR_Imprimir->set_sensitive (true);
	}

void PRINCIPAL::selecionar_recibo(const Gtk::TreeModel::Path& caminho , Gtk::TreeViewColumn* coluna )
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;

	contador = re_impressao->get_iter(caminho);
	if (contador)
		{
		registro = *contador;
		if (registro)
			{
			recibo_selecionado = registro;
			BTR_Remover->set_sensitive (true);
			}
		}
	}

void PRINCIPAL::remover_recibo()
	{
	re_impressao->erase(recibo_selecionado);
	BTR_Remover->set_sensitive (false);
	if (total_recibos > 0)
		{
		total_recibos--;
		}
	if (total_recibos == 0)
		{
		BTR_Imprimir->set_sensitive (false);
		}
	tabular2(Editar,ER_Data);
	}

void PRINCIPAL::imprimir_recibos()
	{	
	Gtk::TreeModel::Row registro;
	type_children::iterator i;
	IMPRIMIR *print;
	int tipo, recibo, ir;
	string data;
	Glib::ustring AUX;
	char *aux;

	type_children children = re_impressao->children();
	for(i = children.begin(); i != children.end(); ++i)
		{
		registro = *i;
		if(registro)
			{
			tipo = registro[arvore_reg.tipo];
			AUX.clear();
			AUX = registro[arvore_reg.data];
			aux = new char[32];
			strcpy(aux,AUX.c_str());
			data.clear();
			data.append(data_formatada(aux,1));
			delete aux;
			recibo = registro[arvore_reg.recibo];
			print = new IMPRIMIR(conexao,tipo,data,recibo);
			}	
		}
	BTR_Imprimir->set_sensitive (false);
	BTR_Adicionar->set_sensitive (false);
	tabular2(Editar,ER_Data);
	total_recibos = 0;
	re_impressao = Gtk::ListStore::create(arvore_reg);
	T_Recs->set_model(re_impressao);
	T_Recs->signal_row_activated ().connect (sigc::mem_fun(*this,&PRINCIPAL::selecionar_recibo));
	T_Recs->remove_all_columns ();
	T_Recs->append_column_numeric (Glib::ustring("Tipo"), arvore_reg.tipo, "%d");
	T_Recs->append_column (Glib::ustring("Data"), arvore_reg.data);
	T_Recs->append_column_numeric (Glib::ustring("Recibo"), arvore_reg.recibo, "%d");
	T_Recs->append_column_numeric (Glib::ustring("Valor"), arvore_reg.valor, "%0.2f");
	for(ir=0; ir < 4; ir++)
		{
		Gtk::TreeView::Column* coluna_temp = T_Recs->get_column(ir);
		coluna_temp->set_reorderable();	
		}
	}

void PRINCIPAL::livro_caixa ()
	{
	LCAIXA *caixa;

	caixa = new LCAIXA(conexao);
	Gtk::Main::run(*caixa);
	}

void PRINCIPAL::cconta(int janela)
	{
	CCONTA *conta;

	conta = new CCONTA(conexao, janela);
	Gtk::Main::run(*conta->Janela);
	
	}